From c7f8626040415d76a0b060b477e86cf9842197f9 Mon Sep 17 00:00:00 2001
From: yangit <yan@yan.my>
Date: Fri, 24 May 2013 15:03:20 +0800
Subject: [PATCH] Coffee sourceMaps!

---
 Makefile                 |    3 +-
 README.md                |    1 +
 browser/browser.debug.js | 8127 ++++++++++++++++++++++++++++++++++++++
 browser/browser.js       |    8 +-
 4 files changed, 8134 insertions(+), 5 deletions(-)
 create mode 100644 browser/browser.debug.js

diff --git a/Makefile b/Makefile
index 46a752283a..ba06733c21 100644
--- a/Makefile
+++ b/Makefile
@@ -1,2 +1,3 @@
 compile:
-	./node_modules/browserify/bin/cmd.js -t coffeeify ./script/index.js > browser/browser.js
\ No newline at end of file
+	./node_modules/browserify/bin/cmd.js -t coffeeify ./script/index.js > browser/browser.js
+	./node_modules/browserify/bin/cmd.js -t coffeeify --debug ./script/index.js > browser/browser.debug.js
\ No newline at end of file
diff --git a/README.md b/README.md
index 6efa08f084..69ff95c266 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,7 @@ Shared resources useful for the multiple HabitRPG repositories, that way all the
     * `var shared = require('./index.js')` or `require('./script/algos.coffee')` if you only need one file.
 * Browser
     * Use `<script/>` tag to include ./browser/browser.js it will export `window.habitrpgShared` object.
+    * Use `browser.debug.js' if you want to have sourcemaps.
 
 
 * Note how to invoke scoring function:
diff --git a/browser/browser.debug.js b/browser/browser.debug.js
new file mode 100644
index 0000000000..eae334453b
--- /dev/null
+++ b/browser/browser.debug.js
@@ -0,0 +1,8127 @@
+;(function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({1:[function(require,module,exports){
+exports.algos = require('./algos.coffee');
+exports.items = require('./items.coffee');
+exports.helpers = require('./helpers.coffee');
+
+try {
+    window;
+    window.habitrpgShared = exports;
+} catch(e) {}
+},{"./algos.coffee":2,"./items.coffee":3,"./helpers.coffee":4}],2:[function(require,module,exports){
+(function() {
+  var HP, XP, hatchingPotions, helpers, items, moment, obj, pets, randomDrop, updateStats, _, _ref,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  moment = require('moment');
+
+  _ = require('lodash');
+
+  helpers = require('./helpers.coffee');
+
+  items = require('./items.coffee');
+
+  _ref = items.items, pets = _ref.pets, hatchingPotions = _ref.hatchingPotions;
+
+  XP = 15;
+
+  HP = 2;
+
+  obj = module.exports = {};
+
+  obj.priorityValue = function(priority) {
+    if (priority == null) {
+      priority = '!';
+    }
+    switch (priority) {
+      case '!':
+        return 1;
+      case '!!':
+        return 1.5;
+      case '!!!':
+        return 2;
+      default:
+        return 1;
+    }
+  };
+
+  obj.tnl = function(level) {
+    var value;
+
+    if (level >= 100) {
+      value = 0;
+    } else {
+      value = Math.round(((Math.pow(level, 2) * 0.25) + (10 * level) + 139.75) / 10) * 10;
+    }
+    return value;
+  };
+
+  /*
+    Calculates Exp modificaiton based on level and weapon strength
+    {value} task.value for exp gain
+    {weaponStrength) weapon strength
+    {level} current user level
+    {priority} user-defined priority multiplier
+  */
+
+
+  obj.expModifier = function(value, weaponStr, level, priority) {
+    var exp, str, strMod, totalStr;
+
+    if (priority == null) {
+      priority = '!';
+    }
+    str = (level - 1) / 2;
+    totalStr = (str + weaponStr) / 100;
+    strMod = 1 + totalStr;
+    exp = value * XP * strMod * obj.priorityValue(priority);
+    return Math.round(exp);
+  };
+
+  /*
+    Calculates HP modification based on level and armor defence
+    {value} task.value for hp loss
+    {armorDefense} defense from armor
+    {helmDefense} defense from helm
+    {level} current user level
+    {priority} user-defined priority multiplier
+  */
+
+
+  obj.hpModifier = function(value, armorDef, helmDef, shieldDef, level, priority) {
+    var def, defMod, hp, totalDef;
+
+    if (priority == null) {
+      priority = '!';
+    }
+    def = (level - 1) / 2;
+    totalDef = (def + armorDef + helmDef + shieldDef) / 100;
+    defMod = 1 - totalDef;
+    hp = value * HP * defMod * obj.priorityValue(priority);
+    return Math.round(hp * 10) / 10;
+  };
+
+  /*
+    Future use
+    {priority} user-defined priority multiplier
+  */
+
+
+  obj.gpModifier = function(value, modifier, priority, streak, user) {
+    var afterStreak, streakBonus, val, _ref1;
+
+    if (priority == null) {
+      priority = '!';
+    }
+    val = value * modifier * obj.priorityValue(priority);
+    if (streak && user) {
+      streakBonus = streak / 100 + 1;
+      afterStreak = val * streakBonus;
+      if (val > 0) {
+        ((_ref1 = user._tmp) != null ? _ref1 : user._tmp = {}).streakBonus = afterStreak - val;
+      }
+      return afterStreak;
+    } else {
+      return val;
+    }
+  };
+
+  /*
+    Calculates the next task.value based on direction
+    Uses a capped inverse log y=.95^x, y>= -5
+    {currentValue} the current value of the task
+    {direction} up or down
+  */
+
+
+  obj.taskDeltaFormula = function(currentValue, direction) {
+    var delta;
+
+    if (currentValue < -47.27) {
+      currentValue = -47.27;
+    } else if (currentValue > 21.27) {
+      currentValue = 21.27;
+    }
+    delta = Math.pow(0.9747, currentValue);
+    if (direction === 'up') {
+      return delta;
+    }
+    return -delta;
+  };
+
+  /*
+    Drop System
+  */
+
+
+  randomDrop = function(user, delta, priority, streak, paths) {
+    var acceptableDrops, chanceMultiplier, drop, rarity, reachedDropLimit, _base, _base1, _base2, _ref1, _ref2, _ref3, _ref4, _ref5;
+
+    if (streak == null) {
+      streak = 0;
+    }
+    if ((_ref1 = (_base = user.items).lastDrop) == null) {
+      _base.lastDrop = {
+        date: +moment().subtract('d', 1),
+        count: 0
+      };
+    }
+    paths['items.lastDrop'] = true;
+    reachedDropLimit = (helpers.daysBetween(user.items.lastDrop.date, +(new Date)) === 0) && (user.items.lastDrop.count >= 2);
+    if (reachedDropLimit) {
+      return;
+    }
+    chanceMultiplier = Math.abs(delta);
+    chanceMultiplier *= obj.priorityValue(priority);
+    chanceMultiplier += streak;
+    if (((_ref2 = user.flags) != null ? _ref2.dropsEnabled : void 0) && Math.random() < (.05 * chanceMultiplier)) {
+      rarity = Math.random();
+      if (rarity > .6) {
+        drop = helpers.randomVal(pets);
+        ((_ref3 = (_base1 = user.items).eggs) != null ? _ref3 : _base1.eggs = []).push(drop);
+        paths['items.eggs'] = true;
+        drop.type = 'Egg';
+        drop.dialog = "You've found a " + drop.text + " Egg! " + drop.notes;
+      } else {
+        acceptableDrops = [];
+        if (rarity < .1) {
+          acceptableDrops = ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton', 'Zombie', 'CottonCandyPink', 'CottonCandyBlue', 'Golden'];
+        } else if (rarity < .2) {
+          acceptableDrops = ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton', 'Zombie', 'CottonCandyPink', 'CottonCandyBlue'];
+        } else if (rarity < .3) {
+          acceptableDrops = ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton'];
+        } else if (rarity < .4) {
+          acceptableDrops = ['Base', 'White', 'Desert'];
+        } else {
+          acceptableDrops = ['Base'];
+        }
+        acceptableDrops = hatchingPotions.filter(function(hatchingPotion) {
+          var _ref4;
+
+          return _ref4 = hatchingPotion.name, __indexOf.call(acceptableDrops, _ref4) >= 0;
+        });
+        drop = helpers.randomVal(acceptableDrops);
+        ((_ref4 = (_base2 = user.items).hatchingPotions) != null ? _ref4 : _base2.hatchingPotions = []).push(drop.name);
+        paths['items.hatchingPotions'] = true;
+        drop.type = 'HatchingPotion';
+        drop.dialog = "You've found a " + drop.text + " Hatching Potion! " + drop.notes;
+      }
+      ((_ref5 = user._tmp) != null ? _ref5 : user._tmp = {}).drop = drop;
+      user.items.lastDrop.date = +(new Date);
+      user.items.lastDrop.count++;
+      return paths['items.lastDrop'] = true;
+    }
+  };
+
+  obj.score = function(user, task, direction, options) {
+    var addPoints, calculateDelta, cron, delta, exp, gp, hp, lvl, num, paths, priority, streak, subtractPoints, times, type, value, _ref1, _ref2, _ref3;
+
+    if (options == null) {
+      options = {};
+    }
+    _ref1 = user.stats, gp = _ref1.gp, hp = _ref1.hp, exp = _ref1.exp, lvl = _ref1.lvl;
+    type = task.type, value = task.value, streak = task.streak;
+    _ref2 = [options.paths || {}, options.times || 1, options.cron || false], paths = _ref2[0], times = _ref2[1], cron = _ref2[2];
+    priority = task.priority || '!';
+    if (task.value > user.stats.gp && task.type === 'reward') {
+      if (!confirm("Not enough GP to purchase this reward, buy anyway and lose HP? (Punishment for taking a reward you didn't earn).")) {
+        return;
+      }
+    }
+    delta = 0;
+    calculateDelta = function(adjustvalue) {
+      if (adjustvalue == null) {
+        adjustvalue = true;
+      }
+      return _.times(times, function() {
+        var nextDelta;
+
+        nextDelta = obj.taskDeltaFormula(value, direction);
+        if (adjustvalue) {
+          value += nextDelta;
+        }
+        return delta += nextDelta;
+      });
+    };
+    addPoints = function() {
+      var level, weaponStrength;
+
+      level = user.stats.lvl;
+      weaponStrength = items.items.weapon[user.items.weapon].strength;
+      exp += obj.expModifier(delta, weaponStrength, level, priority) / 2;
+      if (streak) {
+        return gp += obj.gpModifier(delta, 1, priority, streak, user);
+      } else {
+        return gp += obj.gpModifier(delta, 1, priority);
+      }
+    };
+    subtractPoints = function() {
+      var armorDefense, helmDefense, level, shieldDefense;
+
+      level = user.stats.lvl;
+      armorDefense = items.items.armor[user.items.armor].defense;
+      helmDefense = items.items.head[user.items.head].defense;
+      shieldDefense = items.items.shield[user.items.shield].defense;
+      return hp += obj.hpModifier(delta, armorDefense, helmDefense, shieldDefense, level, priority);
+    };
+    switch (type) {
+      case 'habit':
+        calculateDelta();
+        if (delta > 0) {
+          addPoints();
+        } else {
+          subtractPoints();
+        }
+        if (task.value !== value) {
+          ((_ref3 = task.history) != null ? _ref3 : task.history = []).push({
+            date: +(new Date),
+            value: value
+          });
+          paths["tasks." + task.id + ".history"] = true;
+        }
+        break;
+      case 'daily':
+        if (cron) {
+          calculateDelta();
+          subtractPoints();
+          task.streak = 0;
+        } else {
+          calculateDelta(false);
+          if (delta !== 0) {
+            addPoints();
+            if (direction === 'up') {
+              streak = streak ? streak + 1 : 1;
+            } else {
+              streak = streak ? streak - 1 : 0;
+            }
+            task.streak = streak;
+          }
+        }
+        paths["tasks." + task.id + ".streak"] = true;
+        break;
+      case 'todo':
+        if (cron) {
+          calculateDelta();
+        } else {
+          calculateDelta();
+          addPoints();
+        }
+        break;
+      case 'reward':
+        calculateDelta(false);
+        gp -= Math.abs(task.value);
+        num = parseFloat(task.value).toFixed(2);
+        if (gp < 0) {
+          hp += gp;
+          gp = 0;
+        }
+    }
+    task.value = value;
+    paths["tasks." + task.id + ".value"] = true;
+    updateStats(user, {
+      hp: hp,
+      exp: exp,
+      gp: gp
+    }, paths);
+    if (direction === 'up') {
+      randomDrop(user, delta, priority, streak, paths);
+    }
+    return delta;
+  };
+
+  /*
+    Updates user stats with new stats. Handles death, leveling up, etc
+    {stats} new stats
+    {update} if aggregated changes, pass in userObj as update. otherwise commits will be made immediately
+  */
+
+
+  updateStats = function(user, newStats, paths) {
+    var gp, tnl, _ref1;
+
+    if (user.stats.hp <= 0) {
+      return;
+    }
+    if (newStats.hp != null) {
+      if (newStats.hp <= 0) {
+        user.stats.hp = 0;
+        return;
+      } else {
+        user.stats.hp = newStats.hp;
+      }
+      paths['stats.hp'] = true;
+    }
+    if (newStats.exp != null) {
+      tnl = obj.tnl(user.stats.lvl);
+      if (user.stats.lvl >= 100) {
+        newStats.gp += newStats.exp / 15;
+        newStats.exp = 0;
+        user.stats.lvl = 100;
+      } else {
+        if (newStats.exp >= tnl) {
+          user.stats.exp = newStats.exp;
+          while (newStats.exp >= tnl && user.stats.lvl < 100) {
+            newStats.exp -= tnl;
+            user.stats.lvl++;
+            tnl = obj.tnl(user.stats.lvl);
+          }
+          if (user.stats.lvl === 100) {
+            newStats.exp = 0;
+          }
+          user.stats.hp = 50;
+        }
+      }
+      user.stats.exp = newStats.exp;
+      paths["stats.exp"] = true;
+      paths['stats.lvl'] = true;
+      paths['stats.gp'] = true;
+      paths['stats.hp'] = true;
+      if ((_ref1 = user.flags) == null) {
+        user.flags = {};
+      }
+      if (!user.flags.customizationsNotification && (user.stats.exp > 10 || user.stats.lvl > 1)) {
+        user.flags.customizationsNotification = true;
+        paths['flags.customizationsNotification'] = true;
+      }
+      if (!user.flags.itemsEnabled && user.stats.lvl >= 2) {
+        user.flags.itemsEnabled = true;
+        paths['flags.itemsEnabled'] = true;
+      }
+      if (!user.flags.partyEnabled && user.stats.lvl >= 3) {
+        user.flags.partyEnabled = true;
+        paths['flags.partyEnabled'] = true;
+      }
+      if (!user.flags.dropsEnabled && user.stats.lvl >= 4) {
+        user.flags.dropsEnabled = true;
+        paths['flags.dropsEnabled'] = true;
+      }
+    }
+    if (newStats.gp != null) {
+      if ((typeof gp === "undefined" || gp === null) || gp < 0) {
+        gp = 0.0;
+      }
+      return user.stats.gp = newStats.gp;
+    }
+  };
+
+  obj.shouldCron = function(user) {
+    var _ref1;
+
+    if ((user.lastCron == null) || user.lastCron === 'new' || helpers.daysBetween(user.lastCron, +(new Date), (_ref1 = user.preferences) != null ? _ref1.dayStart : void 0) > 0) {
+      return true;
+    }
+  };
+
+  /*
+    At end of day, add value to all incomplete Daily & Todo tasks (further incentive)
+    For incomplete Dailys, deduct experience
+    Make sure to run this function once in a while as server will not take care of overnight calculations.
+    And you have to run it every time client connects.
+  */
+
+
+  obj.cron = function(user, paths) {
+    var daysMissed, expTally, lastCron, lvl, today, todoTally, _base, _base1, _ref1, _ref2, _ref3, _ref4;
+
+    if (paths == null) {
+      paths = {};
+    }
+    today = +(new Date);
+    lastCron = user.lastCron;
+    if ((lastCron == null) || lastCron === 'new' || moment(lastCron).isAfter(today)) {
+      user.lastCron = today;
+      paths['lastCron'] = true;
+      return;
+    }
+    daysMissed = helpers.daysBetween(user.lastCron, today, (_ref1 = user.preferences) != null ? _ref1.dayStart : void 0);
+    if (daysMissed > 0) {
+      user.lastCron = today;
+      paths['lastCron'] = true;
+      if (user.flags.rest === true) {
+        return;
+      }
+      todoTally = 0;
+      user.todos.concat(user.dailys).forEach(function(task) {
+        var absVal, completed, id, repeat, scheduleMisses, type, _ref2;
+
+        id = task.id, type = task.type, completed = task.completed, repeat = task.repeat;
+        if (!completed) {
+          scheduleMisses = daysMissed;
+          if ((type === 'daily') && repeat) {
+            scheduleMisses = 0;
+            _.times(daysMissed, function(n) {
+              var thatDay, _ref2;
+
+              thatDay = moment(today).subtract('days', n + 1);
+              if (helpers.shouldDo(thatDay, repeat, (_ref2 = obj.preferences) != null ? _ref2.dayStart : void 0) === true) {
+                return scheduleMisses++;
+              }
+            });
+          }
+          if (scheduleMisses > 0) {
+            obj.score(user, task, 'down', {
+              times: scheduleMisses,
+              cron: true,
+              paths: paths
+            });
+          }
+        }
+        switch (type) {
+          case 'daily':
+            if (completed) {
+              task.value = task.value + obj.taskDeltaFormula(task.value, 'up');
+            }
+            ((_ref2 = task.history) != null ? _ref2 : task.history = []).push({
+              date: +(new Date),
+              value: task.value
+            });
+            task.completed = false;
+            paths["tasks." + task.id + ".value"] = true;
+            paths["tasks." + task.id + ".history"] = true;
+            return paths["tasks." + task.id + ".completed"] = true;
+          case 'todo':
+            absVal = completed ? Math.abs(task.value) : task.value;
+            return todoTally += absVal;
+        }
+      });
+      user.habits.forEach(function(task) {
+        if (task.up === false || task.down === false) {
+          if (Math.abs(task.value) < 0.1) {
+            task.value = 0;
+          } else {
+            task.value = task.value / 2;
+          }
+          return paths["tasks." + task.id + ".value"] = true;
+        }
+      });
+      ((_ref2 = (_base = ((_ref3 = user.history) != null ? _ref3 : user.history = {})).todos) != null ? _ref2 : _base.todos = []).push({
+        date: today,
+        value: todoTally
+      });
+      expTally = user.stats.exp;
+      lvl = 0;
+      while (lvl < (user.stats.lvl - 1)) {
+        lvl++;
+        expTally += obj.tnl(lvl);
+      }
+      ((_ref4 = (_base1 = user.history).exp) != null ? _ref4 : _base1.exp = []).push({
+        date: today,
+        value: expTally
+      });
+      paths["history"] = true;
+      return user;
+    }
+  };
+
+}).call(this);
+
+
+},{"./helpers.coffee":4,"./items.coffee":3,"moment":5,"lodash":6}],3:[function(require,module,exports){
+(function() {
+  var items, _;
+
+  _ = require('lodash');
+
+  items = module.exports.items = {
+    weapon: [
+      {
+        index: 0,
+        text: "Training Sword",
+        classes: "weapon_0",
+        notes: 'Training weapon.',
+        strength: 0,
+        value: 0
+      }, {
+        index: 1,
+        text: "Sword",
+        classes: 'weapon_1',
+        notes: 'Increases experience gain by 3%.',
+        strength: 3,
+        value: 20
+      }, {
+        index: 2,
+        text: "Axe",
+        classes: 'weapon_2',
+        notes: 'Increases experience gain by 6%.',
+        strength: 6,
+        value: 30
+      }, {
+        index: 3,
+        text: "Morningstar",
+        classes: 'weapon_3',
+        notes: 'Increases experience gain by 9%.',
+        strength: 9,
+        value: 45
+      }, {
+        index: 4,
+        text: "Blue Sword",
+        classes: 'weapon_4',
+        notes: 'Increases experience gain by 12%.',
+        strength: 12,
+        value: 65
+      }, {
+        index: 5,
+        text: "Red Sword",
+        classes: 'weapon_5',
+        notes: 'Increases experience gain by 15%.',
+        strength: 15,
+        value: 90
+      }, {
+        index: 6,
+        text: "Golden Sword",
+        classes: 'weapon_6',
+        notes: 'Increases experience gain by 18%.',
+        strength: 18,
+        value: 120
+      }, {
+        index: 7,
+        text: "Dark Souls Blade",
+        classes: 'weapon_7',
+        notes: 'Increases experience gain by 21%.',
+        strength: 21,
+        value: 150
+      }
+    ],
+    armor: [
+      {
+        index: 0,
+        text: "Cloth Armor",
+        classes: 'armor_0',
+        notes: 'Training armor.',
+        defense: 0,
+        value: 0
+      }, {
+        index: 1,
+        text: "Leather Armor",
+        classes: 'armor_1',
+        notes: 'Decreases HP loss by 4%.',
+        defense: 4,
+        value: 30
+      }, {
+        index: 2,
+        text: "Chain Mail",
+        classes: 'armor_2',
+        notes: 'Decreases HP loss by 6%.',
+        defense: 6,
+        value: 45
+      }, {
+        index: 3,
+        text: "Plate Mail",
+        classes: 'armor_3',
+        notes: 'Decreases HP loss by 7%.',
+        defense: 7,
+        value: 65
+      }, {
+        index: 4,
+        text: "Red Armor",
+        classes: 'armor_4',
+        notes: 'Decreases HP loss by 8%.',
+        defense: 8,
+        value: 90
+      }, {
+        index: 5,
+        text: "Golden Armor",
+        classes: 'armor_5',
+        notes: 'Decreases HP loss by 10%.',
+        defense: 10,
+        value: 120
+      }, {
+        index: 6,
+        text: "Shade Armor",
+        classes: 'armor_6',
+        notes: 'Decreases HP loss by 12%.',
+        defense: 12,
+        value: 150
+      }
+    ],
+    head: [
+      {
+        index: 0,
+        text: "No Helm",
+        classes: 'head_0',
+        notes: 'Training helm.',
+        defense: 0,
+        value: 0
+      }, {
+        index: 1,
+        text: "Leather Helm",
+        classes: 'head_1',
+        notes: 'Decreases HP loss by 2%.',
+        defense: 2,
+        value: 15
+      }, {
+        index: 2,
+        text: "Chain Coif",
+        classes: 'head_2',
+        notes: 'Decreases HP loss by 3%.',
+        defense: 3,
+        value: 25
+      }, {
+        index: 3,
+        text: "Plate Helm",
+        classes: 'head_3',
+        notes: 'Decreases HP loss by 4%.',
+        defense: 4,
+        value: 45
+      }, {
+        index: 4,
+        text: "Red Helm",
+        classes: 'head_4',
+        notes: 'Decreases HP loss by 5%.',
+        defense: 5,
+        value: 60
+      }, {
+        index: 5,
+        text: "Golden Helm",
+        classes: 'head_5',
+        notes: 'Decreases HP loss by 6%.',
+        defense: 6,
+        value: 80
+      }, {
+        index: 6,
+        text: "Shade Helm",
+        classes: 'head_6',
+        notes: 'Decreases HP loss by 7%.',
+        defense: 7,
+        value: 100
+      }
+    ],
+    shield: [
+      {
+        index: 0,
+        text: "No Shield",
+        classes: 'shield_0',
+        notes: 'No Shield.',
+        defense: 0,
+        value: 0
+      }, {
+        index: 1,
+        text: "Wooden Shield",
+        classes: 'shield_1',
+        notes: 'Decreases HP loss by 3%',
+        defense: 3,
+        value: 20
+      }, {
+        index: 2,
+        text: "Buckler",
+        classes: 'shield_2',
+        notes: 'Decreases HP loss by 4%.',
+        defense: 4,
+        value: 35
+      }, {
+        index: 3,
+        text: "Enforced Shield",
+        classes: 'shield_3',
+        notes: 'Decreases HP loss by 5%.',
+        defense: 5,
+        value: 55
+      }, {
+        index: 4,
+        text: "Red Shield",
+        classes: 'shield_4',
+        notes: 'Decreases HP loss by 7%.',
+        defense: 7,
+        value: 70
+      }, {
+        index: 5,
+        text: "Golden Shield",
+        classes: 'shield_5',
+        notes: 'Decreases HP loss by 8%.',
+        defense: 8,
+        value: 90
+      }, {
+        index: 6,
+        text: "Tormented Skull",
+        classes: 'shield_6',
+        notes: 'Decreases HP loss by 9%.',
+        defense: 9,
+        value: 120
+      }
+    ],
+    potion: {
+      type: 'potion',
+      text: "Potion",
+      notes: "Recover 15 HP (Instant Use)",
+      value: 25,
+      classes: 'potion'
+    },
+    reroll: {
+      type: 'reroll',
+      text: "Re-Roll",
+      classes: 'reroll',
+      notes: "Resets your task values back to 0 (yellow). Useful when everything's red and it's hard to stay alive.",
+      value: 0
+    },
+    pets: [
+      {
+        text: 'Wolf',
+        name: 'Wolf',
+        value: 3
+      }, {
+        text: 'Tiger Cub',
+        name: 'TigerCub',
+        value: 3
+      }, {
+        text: 'Panda Cub',
+        name: 'PandaCub',
+        value: 3
+      }, {
+        text: 'Lion Cub',
+        name: 'LionCub',
+        value: 3
+      }, {
+        text: 'Fox',
+        name: 'Fox',
+        value: 3
+      }, {
+        text: 'Flying Pig',
+        name: 'FlyingPig',
+        value: 3
+      }, {
+        text: 'Dragon',
+        name: 'Dragon',
+        value: 3
+      }, {
+        text: 'Cactus',
+        name: 'Cactus',
+        value: 3
+      }, {
+        text: 'Bear Cub',
+        name: 'BearCub',
+        value: 3
+      }
+    ],
+    hatchingPotions: [
+      {
+        text: 'Base',
+        name: 'Base',
+        notes: "Hatches your pet in it's base form.",
+        value: 1
+      }, {
+        text: 'White',
+        name: 'White',
+        notes: 'Turns your animal into a White pet.',
+        value: 2
+      }, {
+        text: 'Desert',
+        name: 'Desert',
+        notes: 'Turns your animal into a Desert pet.',
+        value: 2
+      }, {
+        text: 'Red',
+        name: 'Red',
+        notes: 'Turns your animal into a Red pet.',
+        value: 3
+      }, {
+        text: 'Shade',
+        name: 'Shade',
+        notes: 'Turns your animal into a Shade pet.',
+        value: 3
+      }, {
+        text: 'Skeleton',
+        name: 'Skeleton',
+        notes: 'Turns your animal into a Skeleton.',
+        value: 3
+      }, {
+        text: 'Zombie',
+        name: 'Zombie',
+        notes: 'Turns your animal into a Zombie.',
+        value: 4
+      }, {
+        text: 'Cotton Candy Pink',
+        name: 'CottonCandyPink',
+        notes: 'Turns your animal into a Cotton Candy Pink pet.',
+        value: 4
+      }, {
+        text: 'Cotton Candy Blue',
+        name: 'CottonCandyBlue',
+        notes: 'Turns your animal into a Cotton Candy Blue pet.',
+        value: 4
+      }, {
+        text: 'Golden',
+        name: 'Golden',
+        notes: 'Turns your animal into a Golden pet.',
+        value: 5
+      }
+    ]
+  };
+
+  _.each(['weapon', 'armor', 'head', 'shield'], function(key) {
+    return _.each(items[key], function(item) {
+      return item.type = key;
+    });
+  });
+
+  _.each(items.pets, function(pet) {
+    return pet.notes = 'Find a hatching potion to pour on this egg, and one day it will hatch into a loyal pet.';
+  });
+
+  _.each(items.hatchingPotions, function(hatchingPotion) {
+    return hatchingPotion.notes = "Pour this on an egg, and it will hatch as a " + hatchingPotion.text + " pet.";
+  });
+
+  module.exports.buyItem = function(user, type, value, index) {
+    var changes, hp;
+
+    if (user.stats.gp < value) {
+      return false;
+    }
+    changes = {};
+    switch (type) {
+      case 'weapon':
+        changes['items.weapon'] = index;
+        break;
+      case 'armor':
+        changes['items.armor'] = index;
+        break;
+      case 'head':
+        changes['items.head'] = index;
+        break;
+      case 'shield':
+        changes['items.shield'] = index;
+        break;
+      case 'potion':
+        hp = user.stats.hp;
+        hp += 15;
+        if (hp > 50) {
+          hp = 50;
+        }
+        changes['stats.hp'] = hp;
+    }
+    changes['stats.gp'] = user.stats.gp - value;
+    return changes;
+  };
+
+  /*
+    update store
+  */
+
+
+  module.exports.updateStore = function(user) {
+    var changes;
+
+    changes = {};
+    _.each(['weapon', 'armor', 'shield', 'head'], function(type) {
+      var i, showNext, _ref, _ref1, _ref2;
+
+      i = parseInt(((_ref = user.items) != null ? _ref[type] : void 0) || 0) + 1;
+      showNext = true;
+      if (i === items[type].length - 1) {
+        if ((type === 'armor' || type === 'shield' || type === 'head')) {
+          showNext = ((_ref1 = user.backer) != null ? _ref1.tier : void 0) && user.backer.tier >= 45;
+        } else {
+          showNext = ((_ref2 = user.backer) != null ? _ref2.tier : void 0) && user.backer.tier >= 70;
+        }
+      } else if (i === items[type].length) {
+        showNext = false;
+      }
+      return changes[type] = showNext ? items[type][i] : {
+        hide: true
+      };
+    });
+    return changes;
+  };
+
+}).call(this);
+
+
+},{"lodash":6}],7:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+    var canSetImmediate = typeof window !== 'undefined'
+    && window.setImmediate;
+    var canPost = typeof window !== 'undefined'
+    && window.postMessage && window.addEventListener
+    ;
+
+    if (canSetImmediate) {
+        return function (f) { return window.setImmediate(f) };
+    }
+
+    if (canPost) {
+        var queue = [];
+        window.addEventListener('message', function (ev) {
+            if (ev.source === window && ev.data === 'process-tick') {
+                ev.stopPropagation();
+                if (queue.length > 0) {
+                    var fn = queue.shift();
+                    fn();
+                }
+            }
+        }, true);
+
+        return function nextTick(fn) {
+            queue.push(fn);
+            window.postMessage('process-tick', '*');
+        };
+    }
+
+    return function nextTick(fn) {
+        setTimeout(fn, 0);
+    };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+
+},{}],4:[function(require,module,exports){
+(function(process){(function() {
+  var algos, dayMapping, daysBetween, items, moment, shouldDo, sod, _;
+
+  moment = require('moment');
+
+  _ = require('lodash');
+
+  algos = require('./algos.coffee');
+
+  items = require('./items.coffee').items;
+
+  sod = function(timestamp, dayStart) {
+    if (dayStart == null) {
+      dayStart = 0;
+    }
+    if (!((dayStart = parseInt(dayStart)) && ((0 <= dayStart && dayStart <= 24)))) {
+      dayStart = 0;
+    }
+    return moment(timestamp).startOf('day').add('h', dayStart);
+  };
+
+  dayMapping = {
+    0: 'su',
+    1: 'm',
+    2: 't',
+    3: 'w',
+    4: 'th',
+    5: 'f',
+    6: 's'
+  };
+
+  /*
+    Absolute diff between two dates
+  */
+
+
+  daysBetween = function(yesterday, now, dayStart) {
+    return Math.abs(sod(yesterday, dayStart).diff(now, 'days'));
+  };
+
+  /*
+    Should the user do this taks on this date, given the task's repeat options and user.preferences.dayStart?
+  */
+
+
+  shouldDo = function(day, repeat, dayStart) {
+    var now, selected, yesterday;
+
+    if (dayStart == null) {
+      dayStart = 0;
+    }
+    if (!repeat) {
+      return false;
+    }
+    now = +(new Date);
+    selected = repeat[dayMapping[sod(day, dayStart).day()]];
+    if (!moment(day).isSame(now, 'd')) {
+      return selected;
+    }
+    if (dayStart <= moment(now).hour()) {
+      return selected;
+    } else {
+      yesterday = moment(now).subtract(1, 'd').day();
+      return repeat[dayMapping[yesterday]];
+    }
+  };
+
+  module.exports = {
+    /*
+      This allows you to set object properties by dot-path. Eg, you can run pathSet('stats.hp',50,user) which is the same as
+      user.stats.hp = 50. This is useful because in our habitrpg-shared functions we're returning changesets as {path:value},
+      so that different consumers can implement setters their own way. Derby needs model.set(path, value) for example, where
+      Angular sets object properties directly - in which case, this function will be used.
+    */
+
+    dotSet: function(path, val, obj) {
+      var arr;
+
+      arr = path.split('.');
+      return _.reduce(arr, function(curr, next, index) {
+        if ((arr.length - 1) === index) {
+          curr[next] = val;
+        }
+        return curr[next];
+      }, obj);
+    },
+    dotGet: function(path, obj) {
+      return _.reduce(path.split('.'), (function(curr, next) {
+        return curr[next];
+      }), obj);
+    },
+    daysBetween: daysBetween,
+    shouldDo: shouldDo,
+    /*
+      Get a random property from an object
+      http://stackoverflow.com/questions/2532218/pick-random-property-from-a-javascript-object
+      returns random property (the value)
+    */
+
+    randomVal: function(obj) {
+      var count, key, result, val;
+
+      result = void 0;
+      count = 0;
+      for (key in obj) {
+        val = obj[key];
+        if (Math.random() < (1 / ++count)) {
+          result = val;
+        }
+      }
+      return result;
+    },
+    /*
+      Remove whitespace #FIXME are we using this anywwhere? Should we be?
+    */
+
+    removeWhitespace: function(str) {
+      if (!str) {
+        return '';
+      }
+      return str.replace(/\s/g, '');
+    },
+    /*
+      Generate the username, since it can be one of many things: their username, their facebook fullname, their manually-set profile name
+    */
+
+    username: function(auth, override) {
+      var fb, _ref;
+
+      if (override) {
+        return override;
+      }
+      if ((auth != null ? (_ref = auth.facebook) != null ? _ref.displayName : void 0 : void 0) != null) {
+        return auth.facebook.displayName;
+      } else if ((auth != null ? auth.facebook : void 0) != null) {
+        fb = auth.facebook;
+        if (fb._raw) {
+          return "" + fb.name.givenName + " " + fb.name.familyName;
+        } else {
+          return fb.name;
+        }
+      } else if ((auth != null ? auth.local : void 0) != null) {
+        return auth.local.username;
+      } else {
+        return 'Anonymous';
+      }
+    },
+    /*
+      Encode the download link for .ics iCal file
+    */
+
+    encodeiCalLink: function(uid, apiToken) {
+      var loc, _ref;
+
+      loc = (typeof window !== "undefined" && window !== null ? window.location.host : void 0) || (typeof process !== "undefined" && process !== null ? (_ref = process.env) != null ? _ref.BASE_URL : void 0 : void 0) || '';
+      return encodeURIComponent("http://" + loc + "/v1/users/" + uid + "/calendar.ics?apiToken=" + apiToken);
+    },
+    /*
+      User's currently equiped item
+    */
+
+    equipped: function(type, item, preferences, backerTier) {
+      var armorSet, gender;
+
+      if (item == null) {
+        item = 0;
+      }
+      if (preferences == null) {
+        preferences = {
+          gender: 'm',
+          armorSet: 'v1'
+        };
+      }
+      if (backerTier == null) {
+        backerTier = 0;
+      }
+      gender = preferences.gender, armorSet = preferences.armorSet;
+      item = parseInt(item);
+      backerTier = parseInt(backerTier);
+      switch (type) {
+        case 'armor':
+          if (item > 5) {
+            if (backerTier >= 45) {
+              return 'armor_6';
+            }
+            item = 5;
+          }
+          if (gender === 'f') {
+            if (item === 0) {
+              return "f_armor_" + item + "_" + armorSet;
+            } else {
+              return "f_armor_" + item;
+            }
+          } else {
+            return "m_armor_" + item;
+          }
+          break;
+        case 'head':
+          if (item > 5) {
+            if (backerTier >= 45) {
+              return 'head_6';
+            }
+            item = 5;
+          }
+          if (gender === 'f') {
+            if (item > 1) {
+              return "f_head_" + item + "_" + armorSet;
+            } else {
+              return "f_head_" + item;
+            }
+          } else {
+            return "m_head_" + item;
+          }
+          break;
+        case 'shield':
+          if (item > 5) {
+            if (backerTier >= 45) {
+              return 'shield_6';
+            }
+            item = 5;
+          }
+          return "" + preferences.gender + "_shield_" + item;
+        case 'weapon':
+          if (item > 6) {
+            if (backerTier >= 70) {
+              return 'weapon_7';
+            }
+            item = 6;
+          }
+          return "" + preferences.gender + "_weapon_" + item;
+      }
+    },
+    /*
+      Gold amount from their money
+    */
+
+    gold: function(num) {
+      if (num) {
+        return num.toFixed(1).split('.')[0];
+      } else {
+        return "0";
+      }
+    },
+    /*
+      Silver amount from their money
+    */
+
+    silver: function(num) {
+      if (num) {
+        return num.toFixed(2).split('.')[1];
+      } else {
+        return "00";
+      }
+    },
+    /*
+      Task classes given everything about the class
+    */
+
+    taskClasses: function(task, filters, dayStart, lastCron, showCompleted) {
+      var classes, completed, enabled, filter, repeat, type, value, _ref;
+
+      if (showCompleted == null) {
+        showCompleted = false;
+      }
+      if (!task) {
+        return;
+      }
+      type = task.type, completed = task.completed, value = task.value, repeat = task.repeat;
+      if ((type === 'todo') && (completed !== showCompleted)) {
+        return 'hidden';
+      }
+      for (filter in filters) {
+        enabled = filters[filter];
+        if (enabled && !((_ref = task.tags) != null ? _ref[filter] : void 0)) {
+          return 'hidden';
+        }
+      }
+      classes = type;
+      if (type === 'todo' || type === 'daily') {
+        if (completed || (type === 'daily' && !shouldDo(+(new Date), task.repeat, dayStart))) {
+          classes += " completed";
+        } else {
+          classes += " uncompleted";
+        }
+      } else if (type === 'habit') {
+        if (task.down && task.up) {
+          classes += ' habit-wide';
+        }
+      }
+      if (value < -20) {
+        classes += ' color-worst';
+      } else if (value < -10) {
+        classes += ' color-worse';
+      } else if (value < -1) {
+        classes += ' color-bad';
+      } else if (value < 1) {
+        classes += ' color-neutral';
+      } else if (value < 5) {
+        classes += ' color-good';
+      } else if (value < 10) {
+        classes += ' color-better';
+      } else {
+        classes += ' color-best';
+      }
+      return classes;
+    },
+    /*
+      Does the user own this pet?
+    */
+
+    ownsPet: function(pet, userPets) {
+      return _.isArray(userPets) && userPets.indexOf(pet) !== -1;
+    },
+    /*
+      Friendly timestamp
+    */
+
+    friendlyTimestamp: function(timestamp) {
+      return moment(timestamp).format('MM/DD h:mm:ss a');
+    },
+    /*
+      Does user have new chat messages?
+    */
+
+    newChatMessages: function(messages, lastMessageSeen) {
+      if (!((messages != null ? messages.length : void 0) > 0)) {
+        return false;
+      }
+      return (messages != null ? messages[0] : void 0) && (messages[0].id !== lastMessageSeen);
+    },
+    /*
+      Relative Date
+    */
+
+    relativeDate: require('relative-date'),
+    /*
+      are any tags active?
+    */
+
+    noTags: function(tags) {
+      return _.isEmpty(tags) || _.isEmpty(_.filter(tags, function(t) {
+        return t;
+      }));
+    },
+    /*
+      Are there tags applied?
+    */
+
+    appliedTags: function(userTags, taskTags) {
+      var arr;
+
+      arr = [];
+      _.each(userTags, function(t) {
+        if (t == null) {
+          return;
+        }
+        if (taskTags != null ? taskTags[t.id] : void 0) {
+          return arr.push(t.name);
+        }
+      });
+      return arr.join(', ');
+    },
+    /*
+      User stats
+    */
+
+    userStr: function(level) {
+      var str;
+
+      return str = (level - 1) / 2;
+    },
+    totalStr: function(level, weapon) {
+      var str, totalStr;
+
+      if (weapon == null) {
+        weapon = 0;
+      }
+      str = (level - 1) / 2;
+      return totalStr = str + items.weapon[weapon].strength;
+    },
+    userDef: function(level) {
+      var def;
+
+      return def = (level - 1) / 2;
+    },
+    totalDef: function(level, armor, helm, shield) {
+      var def, totalDef;
+
+      if (armor == null) {
+        armor = 0;
+      }
+      if (helm == null) {
+        helm = 0;
+      }
+      if (shield == null) {
+        shield = 0;
+      }
+      def = (level - 1) / 2;
+      return totalDef = def + items.armor[armor].defense + items.head[helm].defense + items.shield[shield].defense;
+    },
+    itemText: function(type, item) {
+      if (item == null) {
+        item = 0;
+      }
+      return items[type][parseInt(item)].text;
+    },
+    itemStat: function(type, item) {
+      if (item == null) {
+        item = 0;
+      }
+      if (type === 'weapon') {
+        return items[type][parseInt(item)].strength;
+      } else {
+        return items[type][parseInt(item)].defense;
+      }
+    }
+  };
+
+}).call(this);
+
+
+})(require("__browserify_process"))
+},{"./algos.coffee":2,"./items.coffee":3,"moment":5,"lodash":6,"relative-date":8,"__browserify_process":7}],5:[function(require,module,exports){
+(function(){// moment.js
+// version : 2.0.0
+// author : Tim Wood
+// license : MIT
+// momentjs.com
+
+(function (undefined) {
+
+    /************************************
+        Constants
+    ************************************/
+
+    var moment,
+        VERSION = "2.0.0",
+        round = Math.round, i,
+        // internal storage for language config files
+        languages = {},
+
+        // check for nodeJS
+        hasModule = (typeof module !== 'undefined' && module.exports),
+
+        // ASP.NET json date format regex
+        aspNetJsonRegex = /^\/?Date\((\-?\d+)/i,
+
+        // format tokens
+        formattingTokens = /(\[[^\[]*\])|(\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYY|YYYY|YY|a|A|hh?|HH?|mm?|ss?|SS?S?|X|zz?|ZZ?|.)/g,
+        localFormattingTokens = /(\[[^\[]*\])|(\\)?(LT|LL?L?L?|l{1,4})/g,
+
+        // parsing tokens
+        parseMultipleFormatChunker = /([0-9a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+)/gi,
+
+        // parsing token regexes
+        parseTokenOneOrTwoDigits = /\d\d?/, // 0 - 99
+        parseTokenOneToThreeDigits = /\d{1,3}/, // 0 - 999
+        parseTokenThreeDigits = /\d{3}/, // 000 - 999
+        parseTokenFourDigits = /\d{1,4}/, // 0 - 9999
+        parseTokenSixDigits = /[+\-]?\d{1,6}/, // -999,999 - 999,999
+        parseTokenWord = /[0-9]*[a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF]+\s*?[\u0600-\u06FF]+/i, // any word (or two) characters or numbers including two word month in arabic.
+        parseTokenTimezone = /Z|[\+\-]\d\d:?\d\d/i, // +00:00 -00:00 +0000 -0000 or Z
+        parseTokenT = /T/i, // T (ISO seperator)
+        parseTokenTimestampMs = /[\+\-]?\d+(\.\d{1,3})?/, // 123456789 123456789.123
+
+        // preliminary iso regex
+        // 0000-00-00 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000
+        isoRegex = /^\s*\d{4}-\d\d-\d\d((T| )(\d\d(:\d\d(:\d\d(\.\d\d?\d?)?)?)?)?([\+\-]\d\d:?\d\d)?)?/,
+        isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',
+
+        // iso time formats and regexes
+        isoTimes = [
+            ['HH:mm:ss.S', /(T| )\d\d:\d\d:\d\d\.\d{1,3}/],
+            ['HH:mm:ss', /(T| )\d\d:\d\d:\d\d/],
+            ['HH:mm', /(T| )\d\d:\d\d/],
+            ['HH', /(T| )\d\d/]
+        ],
+
+        // timezone chunker "+10:00" > ["10", "00"] or "-1530" > ["-15", "30"]
+        parseTimezoneChunker = /([\+\-]|\d\d)/gi,
+
+        // getter and setter names
+        proxyGettersAndSetters = 'Month|Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),
+        unitMillisecondFactors = {
+            'Milliseconds' : 1,
+            'Seconds' : 1e3,
+            'Minutes' : 6e4,
+            'Hours' : 36e5,
+            'Days' : 864e5,
+            'Months' : 2592e6,
+            'Years' : 31536e6
+        },
+
+        // format function strings
+        formatFunctions = {},
+
+        // tokens to ordinalize and pad
+        ordinalizeTokens = 'DDD w W M D d'.split(' '),
+        paddedTokens = 'M D H h m s w W'.split(' '),
+
+        formatTokenFunctions = {
+            M    : function () {
+                return this.month() + 1;
+            },
+            MMM  : function (format) {
+                return this.lang().monthsShort(this, format);
+            },
+            MMMM : function (format) {
+                return this.lang().months(this, format);
+            },
+            D    : function () {
+                return this.date();
+            },
+            DDD  : function () {
+                return this.dayOfYear();
+            },
+            d    : function () {
+                return this.day();
+            },
+            dd   : function (format) {
+                return this.lang().weekdaysMin(this, format);
+            },
+            ddd  : function (format) {
+                return this.lang().weekdaysShort(this, format);
+            },
+            dddd : function (format) {
+                return this.lang().weekdays(this, format);
+            },
+            w    : function () {
+                return this.week();
+            },
+            W    : function () {
+                return this.isoWeek();
+            },
+            YY   : function () {
+                return leftZeroFill(this.year() % 100, 2);
+            },
+            YYYY : function () {
+                return leftZeroFill(this.year(), 4);
+            },
+            YYYYY : function () {
+                return leftZeroFill(this.year(), 5);
+            },
+            a    : function () {
+                return this.lang().meridiem(this.hours(), this.minutes(), true);
+            },
+            A    : function () {
+                return this.lang().meridiem(this.hours(), this.minutes(), false);
+            },
+            H    : function () {
+                return this.hours();
+            },
+            h    : function () {
+                return this.hours() % 12 || 12;
+            },
+            m    : function () {
+                return this.minutes();
+            },
+            s    : function () {
+                return this.seconds();
+            },
+            S    : function () {
+                return ~~(this.milliseconds() / 100);
+            },
+            SS   : function () {
+                return leftZeroFill(~~(this.milliseconds() / 10), 2);
+            },
+            SSS  : function () {
+                return leftZeroFill(this.milliseconds(), 3);
+            },
+            Z    : function () {
+                var a = -this.zone(),
+                    b = "+";
+                if (a < 0) {
+                    a = -a;
+                    b = "-";
+                }
+                return b + leftZeroFill(~~(a / 60), 2) + ":" + leftZeroFill(~~a % 60, 2);
+            },
+            ZZ   : function () {
+                var a = -this.zone(),
+                    b = "+";
+                if (a < 0) {
+                    a = -a;
+                    b = "-";
+                }
+                return b + leftZeroFill(~~(10 * a / 6), 4);
+            },
+            X    : function () {
+                return this.unix();
+            }
+        };
+
+    function padToken(func, count) {
+        return function (a) {
+            return leftZeroFill(func.call(this, a), count);
+        };
+    }
+    function ordinalizeToken(func) {
+        return function (a) {
+            return this.lang().ordinal(func.call(this, a));
+        };
+    }
+
+    while (ordinalizeTokens.length) {
+        i = ordinalizeTokens.pop();
+        formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i]);
+    }
+    while (paddedTokens.length) {
+        i = paddedTokens.pop();
+        formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);
+    }
+    formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);
+
+
+    /************************************
+        Constructors
+    ************************************/
+
+    function Language() {
+
+    }
+
+    // Moment prototype object
+    function Moment(config) {
+        extend(this, config);
+    }
+
+    // Duration Constructor
+    function Duration(duration) {
+        var data = this._data = {},
+            years = duration.years || duration.year || duration.y || 0,
+            months = duration.months || duration.month || duration.M || 0,
+            weeks = duration.weeks || duration.week || duration.w || 0,
+            days = duration.days || duration.day || duration.d || 0,
+            hours = duration.hours || duration.hour || duration.h || 0,
+            minutes = duration.minutes || duration.minute || duration.m || 0,
+            seconds = duration.seconds || duration.second || duration.s || 0,
+            milliseconds = duration.milliseconds || duration.millisecond || duration.ms || 0;
+
+        // representation for dateAddRemove
+        this._milliseconds = milliseconds +
+            seconds * 1e3 + // 1000
+            minutes * 6e4 + // 1000 * 60
+            hours * 36e5; // 1000 * 60 * 60
+        // Because of dateAddRemove treats 24 hours as different from a
+        // day when working around DST, we need to store them separately
+        this._days = days +
+            weeks * 7;
+        // It is impossible translate months into days without knowing
+        // which months you are are talking about, so we have to store
+        // it separately.
+        this._months = months +
+            years * 12;
+
+        // The following code bubbles up values, see the tests for
+        // examples of what that means.
+        data.milliseconds = milliseconds % 1000;
+        seconds += absRound(milliseconds / 1000);
+
+        data.seconds = seconds % 60;
+        minutes += absRound(seconds / 60);
+
+        data.minutes = minutes % 60;
+        hours += absRound(minutes / 60);
+
+        data.hours = hours % 24;
+        days += absRound(hours / 24);
+
+        days += weeks * 7;
+        data.days = days % 30;
+
+        months += absRound(days / 30);
+
+        data.months = months % 12;
+        years += absRound(months / 12);
+
+        data.years = years;
+    }
+
+
+    /************************************
+        Helpers
+    ************************************/
+
+
+    function extend(a, b) {
+        for (var i in b) {
+            if (b.hasOwnProperty(i)) {
+                a[i] = b[i];
+            }
+        }
+        return a;
+    }
+
+    function absRound(number) {
+        if (number < 0) {
+            return Math.ceil(number);
+        } else {
+            return Math.floor(number);
+        }
+    }
+
+    // left zero fill a number
+    // see http://jsperf.com/left-zero-filling for performance comparison
+    function leftZeroFill(number, targetLength) {
+        var output = number + '';
+        while (output.length < targetLength) {
+            output = '0' + output;
+        }
+        return output;
+    }
+
+    // helper function for _.addTime and _.subtractTime
+    function addOrSubtractDurationFromMoment(mom, duration, isAdding) {
+        var ms = duration._milliseconds,
+            d = duration._days,
+            M = duration._months,
+            currentDate;
+
+        if (ms) {
+            mom._d.setTime(+mom + ms * isAdding);
+        }
+        if (d) {
+            mom.date(mom.date() + d * isAdding);
+        }
+        if (M) {
+            currentDate = mom.date();
+            mom.date(1)
+                .month(mom.month() + M * isAdding)
+                .date(Math.min(currentDate, mom.daysInMonth()));
+        }
+    }
+
+    // check if is an array
+    function isArray(input) {
+        return Object.prototype.toString.call(input) === '[object Array]';
+    }
+
+    // compare two arrays, return the number of differences
+    function compareArrays(array1, array2) {
+        var len = Math.min(array1.length, array2.length),
+            lengthDiff = Math.abs(array1.length - array2.length),
+            diffs = 0,
+            i;
+        for (i = 0; i < len; i++) {
+            if (~~array1[i] !== ~~array2[i]) {
+                diffs++;
+            }
+        }
+        return diffs + lengthDiff;
+    }
+
+
+    /************************************
+        Languages
+    ************************************/
+
+
+    Language.prototype = {
+        set : function (config) {
+            var prop, i;
+            for (i in config) {
+                prop = config[i];
+                if (typeof prop === 'function') {
+                    this[i] = prop;
+                } else {
+                    this['_' + i] = prop;
+                }
+            }
+        },
+
+        _months : "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+        months : function (m) {
+            return this._months[m.month()];
+        },
+
+        _monthsShort : "Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec".split("_"),
+        monthsShort : function (m) {
+            return this._monthsShort[m.month()];
+        },
+
+        monthsParse : function (monthName) {
+            var i, mom, regex, output;
+
+            if (!this._monthsParse) {
+                this._monthsParse = [];
+            }
+
+            for (i = 0; i < 12; i++) {
+                // make the regex if we don't have it already
+                if (!this._monthsParse[i]) {
+                    mom = moment([2000, i]);
+                    regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+                    this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+                }
+                // test the regex
+                if (this._monthsParse[i].test(monthName)) {
+                    return i;
+                }
+            }
+        },
+
+        _weekdays : "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+        weekdays : function (m) {
+            return this._weekdays[m.day()];
+        },
+
+        _weekdaysShort : "Sun_Mon_Tue_Wed_Thu_Fri_Sat".split("_"),
+        weekdaysShort : function (m) {
+            return this._weekdaysShort[m.day()];
+        },
+
+        _weekdaysMin : "Su_Mo_Tu_We_Th_Fr_Sa".split("_"),
+        weekdaysMin : function (m) {
+            return this._weekdaysMin[m.day()];
+        },
+
+        _longDateFormat : {
+            LT : "h:mm A",
+            L : "MM/DD/YYYY",
+            LL : "MMMM D YYYY",
+            LLL : "MMMM D YYYY LT",
+            LLLL : "dddd, MMMM D YYYY LT"
+        },
+        longDateFormat : function (key) {
+            var output = this._longDateFormat[key];
+            if (!output && this._longDateFormat[key.toUpperCase()]) {
+                output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {
+                    return val.slice(1);
+                });
+                this._longDateFormat[key] = output;
+            }
+            return output;
+        },
+
+        meridiem : function (hours, minutes, isLower) {
+            if (hours > 11) {
+                return isLower ? 'pm' : 'PM';
+            } else {
+                return isLower ? 'am' : 'AM';
+            }
+        },
+
+        _calendar : {
+            sameDay : '[Today at] LT',
+            nextDay : '[Tomorrow at] LT',
+            nextWeek : 'dddd [at] LT',
+            lastDay : '[Yesterday at] LT',
+            lastWeek : '[last] dddd [at] LT',
+            sameElse : 'L'
+        },
+        calendar : function (key, mom) {
+            var output = this._calendar[key];
+            return typeof output === 'function' ? output.apply(mom) : output;
+        },
+
+        _relativeTime : {
+            future : "in %s",
+            past : "%s ago",
+            s : "a few seconds",
+            m : "a minute",
+            mm : "%d minutes",
+            h : "an hour",
+            hh : "%d hours",
+            d : "a day",
+            dd : "%d days",
+            M : "a month",
+            MM : "%d months",
+            y : "a year",
+            yy : "%d years"
+        },
+        relativeTime : function (number, withoutSuffix, string, isFuture) {
+            var output = this._relativeTime[string];
+            return (typeof output === 'function') ?
+                output(number, withoutSuffix, string, isFuture) :
+                output.replace(/%d/i, number);
+        },
+        pastFuture : function (diff, output) {
+            var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+            return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);
+        },
+
+        ordinal : function (number) {
+            return this._ordinal.replace("%d", number);
+        },
+        _ordinal : "%d",
+
+        preparse : function (string) {
+            return string;
+        },
+
+        postformat : function (string) {
+            return string;
+        },
+
+        week : function (mom) {
+            return weekOfYear(mom, this._week.dow, this._week.doy);
+        },
+        _week : {
+            dow : 0, // Sunday is the first day of the week.
+            doy : 6  // The week that contains Jan 1st is the first week of the year.
+        }
+    };
+
+    // Loads a language definition into the `languages` cache.  The function
+    // takes a key and optionally values.  If not in the browser and no values
+    // are provided, it will load the language file module.  As a convenience,
+    // this function also returns the language values.
+    function loadLang(key, values) {
+        values.abbr = key;
+        if (!languages[key]) {
+            languages[key] = new Language();
+        }
+        languages[key].set(values);
+        return languages[key];
+    }
+
+    // Determines which language definition to use and returns it.
+    //
+    // With no parameters, it will return the global language.  If you
+    // pass in a language key, such as 'en', it will return the
+    // definition for 'en', so long as 'en' has already been loaded using
+    // moment.lang.
+    function getLangDefinition(key) {
+        if (!key) {
+            return moment.fn._lang;
+        }
+        if (!languages[key] && hasModule) {
+            require('./lang/' + key);
+        }
+        return languages[key];
+    }
+
+
+    /************************************
+        Formatting
+    ************************************/
+
+
+    function removeFormattingTokens(input) {
+        if (input.match(/\[.*\]/)) {
+            return input.replace(/^\[|\]$/g, "");
+        }
+        return input.replace(/\\/g, "");
+    }
+
+    function makeFormatFunction(format) {
+        var array = format.match(formattingTokens), i, length;
+
+        for (i = 0, length = array.length; i < length; i++) {
+            if (formatTokenFunctions[array[i]]) {
+                array[i] = formatTokenFunctions[array[i]];
+            } else {
+                array[i] = removeFormattingTokens(array[i]);
+            }
+        }
+
+        return function (mom) {
+            var output = "";
+            for (i = 0; i < length; i++) {
+                output += typeof array[i].call === 'function' ? array[i].call(mom, format) : array[i];
+            }
+            return output;
+        };
+    }
+
+    // format date using native date object
+    function formatMoment(m, format) {
+        var i = 5;
+
+        function replaceLongDateFormatTokens(input) {
+            return m.lang().longDateFormat(input) || input;
+        }
+
+        while (i-- && localFormattingTokens.test(format)) {
+            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+        }
+
+        if (!formatFunctions[format]) {
+            formatFunctions[format] = makeFormatFunction(format);
+        }
+
+        return formatFunctions[format](m);
+    }
+
+
+    /************************************
+        Parsing
+    ************************************/
+
+
+    // get the regex to find the next token
+    function getParseRegexForToken(token) {
+        switch (token) {
+        case 'DDDD':
+            return parseTokenThreeDigits;
+        case 'YYYY':
+            return parseTokenFourDigits;
+        case 'YYYYY':
+            return parseTokenSixDigits;
+        case 'S':
+        case 'SS':
+        case 'SSS':
+        case 'DDD':
+            return parseTokenOneToThreeDigits;
+        case 'MMM':
+        case 'MMMM':
+        case 'dd':
+        case 'ddd':
+        case 'dddd':
+        case 'a':
+        case 'A':
+            return parseTokenWord;
+        case 'X':
+            return parseTokenTimestampMs;
+        case 'Z':
+        case 'ZZ':
+            return parseTokenTimezone;
+        case 'T':
+            return parseTokenT;
+        case 'MM':
+        case 'DD':
+        case 'YY':
+        case 'HH':
+        case 'hh':
+        case 'mm':
+        case 'ss':
+        case 'M':
+        case 'D':
+        case 'd':
+        case 'H':
+        case 'h':
+        case 'm':
+        case 's':
+            return parseTokenOneOrTwoDigits;
+        default :
+            return new RegExp(token.replace('\\', ''));
+        }
+    }
+
+    // function to convert string input to date
+    function addTimeToArrayFromToken(token, input, config) {
+        var a, b,
+            datePartArray = config._a;
+
+        switch (token) {
+        // MONTH
+        case 'M' : // fall through to MM
+        case 'MM' :
+            datePartArray[1] = (input == null) ? 0 : ~~input - 1;
+            break;
+        case 'MMM' : // fall through to MMMM
+        case 'MMMM' :
+            a = getLangDefinition(config._l).monthsParse(input);
+            // if we didn't find a month name, mark the date as invalid.
+            if (a != null) {
+                datePartArray[1] = a;
+            } else {
+                config._isValid = false;
+            }
+            break;
+        // DAY OF MONTH
+        case 'D' : // fall through to DDDD
+        case 'DD' : // fall through to DDDD
+        case 'DDD' : // fall through to DDDD
+        case 'DDDD' :
+            if (input != null) {
+                datePartArray[2] = ~~input;
+            }
+            break;
+        // YEAR
+        case 'YY' :
+            datePartArray[0] = ~~input + (~~input > 68 ? 1900 : 2000);
+            break;
+        case 'YYYY' :
+        case 'YYYYY' :
+            datePartArray[0] = ~~input;
+            break;
+        // AM / PM
+        case 'a' : // fall through to A
+        case 'A' :
+            config._isPm = ((input + '').toLowerCase() === 'pm');
+            break;
+        // 24 HOUR
+        case 'H' : // fall through to hh
+        case 'HH' : // fall through to hh
+        case 'h' : // fall through to hh
+        case 'hh' :
+            datePartArray[3] = ~~input;
+            break;
+        // MINUTE
+        case 'm' : // fall through to mm
+        case 'mm' :
+            datePartArray[4] = ~~input;
+            break;
+        // SECOND
+        case 's' : // fall through to ss
+        case 'ss' :
+            datePartArray[5] = ~~input;
+            break;
+        // MILLISECOND
+        case 'S' :
+        case 'SS' :
+        case 'SSS' :
+            datePartArray[6] = ~~ (('0.' + input) * 1000);
+            break;
+        // UNIX TIMESTAMP WITH MS
+        case 'X':
+            config._d = new Date(parseFloat(input) * 1000);
+            break;
+        // TIMEZONE
+        case 'Z' : // fall through to ZZ
+        case 'ZZ' :
+            config._useUTC = true;
+            a = (input + '').match(parseTimezoneChunker);
+            if (a && a[1]) {
+                config._tzh = ~~a[1];
+            }
+            if (a && a[2]) {
+                config._tzm = ~~a[2];
+            }
+            // reverse offsets
+            if (a && a[0] === '+') {
+                config._tzh = -config._tzh;
+                config._tzm = -config._tzm;
+            }
+            break;
+        }
+
+        // if the input is null, the date is not valid
+        if (input == null) {
+            config._isValid = false;
+        }
+    }
+
+    // convert an array to a date.
+    // the array should mirror the parameters below
+    // note: all values past the year are optional and will default to the lowest possible value.
+    // [year, month, day , hour, minute, second, millisecond]
+    function dateFromArray(config) {
+        var i, date, input = [];
+
+        if (config._d) {
+            return;
+        }
+
+        for (i = 0; i < 7; i++) {
+            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+        }
+
+        // add the offsets to the time to be parsed so that we can have a clean array for checking isValid
+        input[3] += config._tzh || 0;
+        input[4] += config._tzm || 0;
+
+        date = new Date(0);
+
+        if (config._useUTC) {
+            date.setUTCFullYear(input[0], input[1], input[2]);
+            date.setUTCHours(input[3], input[4], input[5], input[6]);
+        } else {
+            date.setFullYear(input[0], input[1], input[2]);
+            date.setHours(input[3], input[4], input[5], input[6]);
+        }
+
+        config._d = date;
+    }
+
+    // date from string and format string
+    function makeDateFromStringAndFormat(config) {
+        // This array is used to make a Date, either with `new Date` or `Date.UTC`
+        var tokens = config._f.match(formattingTokens),
+            string = config._i,
+            i, parsedInput;
+
+        config._a = [];
+
+        for (i = 0; i < tokens.length; i++) {
+            parsedInput = (getParseRegexForToken(tokens[i]).exec(string) || [])[0];
+            if (parsedInput) {
+                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+            }
+            // don't parse if its not a known token
+            if (formatTokenFunctions[tokens[i]]) {
+                addTimeToArrayFromToken(tokens[i], parsedInput, config);
+            }
+        }
+        // handle am pm
+        if (config._isPm && config._a[3] < 12) {
+            config._a[3] += 12;
+        }
+        // if is 12 am, change hours to 0
+        if (config._isPm === false && config._a[3] === 12) {
+            config._a[3] = 0;
+        }
+        // return
+        dateFromArray(config);
+    }
+
+    // date from string and array of format strings
+    function makeDateFromStringAndArray(config) {
+        var tempConfig,
+            tempMoment,
+            bestMoment,
+
+            scoreToBeat = 99,
+            i,
+            currentDate,
+            currentScore;
+
+        while (config._f.length) {
+            tempConfig = extend({}, config);
+            tempConfig._f = config._f.pop();
+            makeDateFromStringAndFormat(tempConfig);
+            tempMoment = new Moment(tempConfig);
+
+            if (tempMoment.isValid()) {
+                bestMoment = tempMoment;
+                break;
+            }
+
+            currentScore = compareArrays(tempConfig._a, tempMoment.toArray());
+
+            if (currentScore < scoreToBeat) {
+                scoreToBeat = currentScore;
+                bestMoment = tempMoment;
+            }
+        }
+
+        extend(config, bestMoment);
+    }
+
+    // date from iso format
+    function makeDateFromString(config) {
+        var i,
+            string = config._i;
+        if (isoRegex.exec(string)) {
+            config._f = 'YYYY-MM-DDT';
+            for (i = 0; i < 4; i++) {
+                if (isoTimes[i][1].exec(string)) {
+                    config._f += isoTimes[i][0];
+                    break;
+                }
+            }
+            if (parseTokenTimezone.exec(string)) {
+                config._f += " Z";
+            }
+            makeDateFromStringAndFormat(config);
+        } else {
+            config._d = new Date(string);
+        }
+    }
+
+    function makeDateFromInput(config) {
+        var input = config._i,
+            matched = aspNetJsonRegex.exec(input);
+
+        if (input === undefined) {
+            config._d = new Date();
+        } else if (matched) {
+            config._d = new Date(+matched[1]);
+        } else if (typeof input === 'string') {
+            makeDateFromString(config);
+        } else if (isArray(input)) {
+            config._a = input.slice(0);
+            dateFromArray(config);
+        } else {
+            config._d = input instanceof Date ? new Date(+input) : new Date(input);
+        }
+    }
+
+
+    /************************************
+        Relative Time
+    ************************************/
+
+
+    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+    function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {
+        return lang.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+    }
+
+    function relativeTime(milliseconds, withoutSuffix, lang) {
+        var seconds = round(Math.abs(milliseconds) / 1000),
+            minutes = round(seconds / 60),
+            hours = round(minutes / 60),
+            days = round(hours / 24),
+            years = round(days / 365),
+            args = seconds < 45 && ['s', seconds] ||
+                minutes === 1 && ['m'] ||
+                minutes < 45 && ['mm', minutes] ||
+                hours === 1 && ['h'] ||
+                hours < 22 && ['hh', hours] ||
+                days === 1 && ['d'] ||
+                days <= 25 && ['dd', days] ||
+                days <= 45 && ['M'] ||
+                days < 345 && ['MM', round(days / 30)] ||
+                years === 1 && ['y'] || ['yy', years];
+        args[2] = withoutSuffix;
+        args[3] = milliseconds > 0;
+        args[4] = lang;
+        return substituteTimeAgo.apply({}, args);
+    }
+
+
+    /************************************
+        Week of Year
+    ************************************/
+
+
+    // firstDayOfWeek       0 = sun, 6 = sat
+    //                      the day of the week that starts the week
+    //                      (usually sunday or monday)
+    // firstDayOfWeekOfYear 0 = sun, 6 = sat
+    //                      the first week is the week that contains the first
+    //                      of this day of the week
+    //                      (eg. ISO weeks use thursday (4))
+    function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {
+        var end = firstDayOfWeekOfYear - firstDayOfWeek,
+            daysToDayOfWeek = firstDayOfWeekOfYear - mom.day();
+
+
+        if (daysToDayOfWeek > end) {
+            daysToDayOfWeek -= 7;
+        }
+
+        if (daysToDayOfWeek < end - 7) {
+            daysToDayOfWeek += 7;
+        }
+
+        return Math.ceil(moment(mom).add('d', daysToDayOfWeek).dayOfYear() / 7);
+    }
+
+
+    /************************************
+        Top Level Functions
+    ************************************/
+
+    function makeMoment(config) {
+        var input = config._i,
+            format = config._f;
+
+        if (input === null || input === '') {
+            return null;
+        }
+
+        if (typeof input === 'string') {
+            config._i = input = getLangDefinition().preparse(input);
+        }
+
+        if (moment.isMoment(input)) {
+            config = extend({}, input);
+            config._d = new Date(+input._d);
+        } else if (format) {
+            if (isArray(format)) {
+                makeDateFromStringAndArray(config);
+            } else {
+                makeDateFromStringAndFormat(config);
+            }
+        } else {
+            makeDateFromInput(config);
+        }
+
+        return new Moment(config);
+    }
+
+    moment = function (input, format, lang) {
+        return makeMoment({
+            _i : input,
+            _f : format,
+            _l : lang,
+            _isUTC : false
+        });
+    };
+
+    // creating with utc
+    moment.utc = function (input, format, lang) {
+        return makeMoment({
+            _useUTC : true,
+            _isUTC : true,
+            _l : lang,
+            _i : input,
+            _f : format
+        });
+    };
+
+    // creating with unix timestamp (in seconds)
+    moment.unix = function (input) {
+        return moment(input * 1000);
+    };
+
+    // duration
+    moment.duration = function (input, key) {
+        var isDuration = moment.isDuration(input),
+            isNumber = (typeof input === 'number'),
+            duration = (isDuration ? input._data : (isNumber ? {} : input)),
+            ret;
+
+        if (isNumber) {
+            if (key) {
+                duration[key] = input;
+            } else {
+                duration.milliseconds = input;
+            }
+        }
+
+        ret = new Duration(duration);
+
+        if (isDuration && input.hasOwnProperty('_lang')) {
+            ret._lang = input._lang;
+        }
+
+        return ret;
+    };
+
+    // version number
+    moment.version = VERSION;
+
+    // default format
+    moment.defaultFormat = isoFormat;
+
+    // This function will load languages and then set the global language.  If
+    // no arguments are passed in, it will simply return the current global
+    // language key.
+    moment.lang = function (key, values) {
+        var i;
+
+        if (!key) {
+            return moment.fn._lang._abbr;
+        }
+        if (values) {
+            loadLang(key, values);
+        } else if (!languages[key]) {
+            getLangDefinition(key);
+        }
+        moment.duration.fn._lang = moment.fn._lang = getLangDefinition(key);
+    };
+
+    // returns language data
+    moment.langData = function (key) {
+        if (key && key._lang && key._lang._abbr) {
+            key = key._lang._abbr;
+        }
+        return getLangDefinition(key);
+    };
+
+    // compare moment object
+    moment.isMoment = function (obj) {
+        return obj instanceof Moment;
+    };
+
+    // for typechecking Duration objects
+    moment.isDuration = function (obj) {
+        return obj instanceof Duration;
+    };
+
+
+    /************************************
+        Moment Prototype
+    ************************************/
+
+
+    moment.fn = Moment.prototype = {
+
+        clone : function () {
+            return moment(this);
+        },
+
+        valueOf : function () {
+            return +this._d;
+        },
+
+        unix : function () {
+            return Math.floor(+this._d / 1000);
+        },
+
+        toString : function () {
+            return this.format("ddd MMM DD YYYY HH:mm:ss [GMT]ZZ");
+        },
+
+        toDate : function () {
+            return this._d;
+        },
+
+        toJSON : function () {
+            return moment.utc(this).format('YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+        },
+
+        toArray : function () {
+            var m = this;
+            return [
+                m.year(),
+                m.month(),
+                m.date(),
+                m.hours(),
+                m.minutes(),
+                m.seconds(),
+                m.milliseconds()
+            ];
+        },
+
+        isValid : function () {
+            if (this._isValid == null) {
+                if (this._a) {
+                    this._isValid = !compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray());
+                } else {
+                    this._isValid = !isNaN(this._d.getTime());
+                }
+            }
+            return !!this._isValid;
+        },
+
+        utc : function () {
+            this._isUTC = true;
+            return this;
+        },
+
+        local : function () {
+            this._isUTC = false;
+            return this;
+        },
+
+        format : function (inputString) {
+            var output = formatMoment(this, inputString || moment.defaultFormat);
+            return this.lang().postformat(output);
+        },
+
+        add : function (input, val) {
+            var dur;
+            // switch args to support add('s', 1) and add(1, 's')
+            if (typeof input === 'string') {
+                dur = moment.duration(+val, input);
+            } else {
+                dur = moment.duration(input, val);
+            }
+            addOrSubtractDurationFromMoment(this, dur, 1);
+            return this;
+        },
+
+        subtract : function (input, val) {
+            var dur;
+            // switch args to support subtract('s', 1) and subtract(1, 's')
+            if (typeof input === 'string') {
+                dur = moment.duration(+val, input);
+            } else {
+                dur = moment.duration(input, val);
+            }
+            addOrSubtractDurationFromMoment(this, dur, -1);
+            return this;
+        },
+
+        diff : function (input, units, asFloat) {
+            var that = this._isUTC ? moment(input).utc() : moment(input).local(),
+                zoneDiff = (this.zone() - that.zone()) * 6e4,
+                diff, output;
+
+            if (units) {
+                // standardize on singular form
+                units = units.replace(/s$/, '');
+            }
+
+            if (units === 'year' || units === 'month') {
+                diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2
+                output = ((this.year() - that.year()) * 12) + (this.month() - that.month());
+                output += ((this - moment(this).startOf('month')) - (that - moment(that).startOf('month'))) / diff;
+                if (units === 'year') {
+                    output = output / 12;
+                }
+            } else {
+                diff = (this - that) - zoneDiff;
+                output = units === 'second' ? diff / 1e3 : // 1000
+                    units === 'minute' ? diff / 6e4 : // 1000 * 60
+                    units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60
+                    units === 'day' ? diff / 864e5 : // 1000 * 60 * 60 * 24
+                    units === 'week' ? diff / 6048e5 : // 1000 * 60 * 60 * 24 * 7
+                    diff;
+            }
+            return asFloat ? output : absRound(output);
+        },
+
+        from : function (time, withoutSuffix) {
+            return moment.duration(this.diff(time)).lang(this.lang()._abbr).humanize(!withoutSuffix);
+        },
+
+        fromNow : function (withoutSuffix) {
+            return this.from(moment(), withoutSuffix);
+        },
+
+        calendar : function () {
+            var diff = this.diff(moment().startOf('day'), 'days', true),
+                format = diff < -6 ? 'sameElse' :
+                diff < -1 ? 'lastWeek' :
+                diff < 0 ? 'lastDay' :
+                diff < 1 ? 'sameDay' :
+                diff < 2 ? 'nextDay' :
+                diff < 7 ? 'nextWeek' : 'sameElse';
+            return this.format(this.lang().calendar(format, this));
+        },
+
+        isLeapYear : function () {
+            var year = this.year();
+            return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+        },
+
+        isDST : function () {
+            return (this.zone() < moment([this.year()]).zone() ||
+                this.zone() < moment([this.year(), 5]).zone());
+        },
+
+        day : function (input) {
+            var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+            return input == null ? day :
+                this.add({ d : input - day });
+        },
+
+        startOf: function (units) {
+            units = units.replace(/s$/, '');
+            // the following switch intentionally omits break keywords
+            // to utilize falling through the cases.
+            switch (units) {
+            case 'year':
+                this.month(0);
+                /* falls through */
+            case 'month':
+                this.date(1);
+                /* falls through */
+            case 'week':
+            case 'day':
+                this.hours(0);
+                /* falls through */
+            case 'hour':
+                this.minutes(0);
+                /* falls through */
+            case 'minute':
+                this.seconds(0);
+                /* falls through */
+            case 'second':
+                this.milliseconds(0);
+                /* falls through */
+            }
+
+            // weeks are a special case
+            if (units === 'week') {
+                this.day(0);
+            }
+
+            return this;
+        },
+
+        endOf: function (units) {
+            return this.startOf(units).add(units.replace(/s?$/, 's'), 1).subtract('ms', 1);
+        },
+
+        isAfter: function (input, units) {
+            units = typeof units !== 'undefined' ? units : 'millisecond';
+            return +this.clone().startOf(units) > +moment(input).startOf(units);
+        },
+
+        isBefore: function (input, units) {
+            units = typeof units !== 'undefined' ? units : 'millisecond';
+            return +this.clone().startOf(units) < +moment(input).startOf(units);
+        },
+
+        isSame: function (input, units) {
+            units = typeof units !== 'undefined' ? units : 'millisecond';
+            return +this.clone().startOf(units) === +moment(input).startOf(units);
+        },
+
+        zone : function () {
+            return this._isUTC ? 0 : this._d.getTimezoneOffset();
+        },
+
+        daysInMonth : function () {
+            return moment.utc([this.year(), this.month() + 1, 0]).date();
+        },
+
+        dayOfYear : function (input) {
+            var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;
+            return input == null ? dayOfYear : this.add("d", (input - dayOfYear));
+        },
+
+        isoWeek : function (input) {
+            var week = weekOfYear(this, 1, 4);
+            return input == null ? week : this.add("d", (input - week) * 7);
+        },
+
+        week : function (input) {
+            var week = this.lang().week(this);
+            return input == null ? week : this.add("d", (input - week) * 7);
+        },
+
+        // If passed a language key, it will set the language for this
+        // instance.  Otherwise, it will return the language configuration
+        // variables for this instance.
+        lang : function (key) {
+            if (key === undefined) {
+                return this._lang;
+            } else {
+                this._lang = getLangDefinition(key);
+                return this;
+            }
+        }
+    };
+
+    // helper for adding shortcuts
+    function makeGetterAndSetter(name, key) {
+        moment.fn[name] = moment.fn[name + 's'] = function (input) {
+            var utc = this._isUTC ? 'UTC' : '';
+            if (input != null) {
+                this._d['set' + utc + key](input);
+                return this;
+            } else {
+                return this._d['get' + utc + key]();
+            }
+        };
+    }
+
+    // loop through and add shortcuts (Month, Date, Hours, Minutes, Seconds, Milliseconds)
+    for (i = 0; i < proxyGettersAndSetters.length; i ++) {
+        makeGetterAndSetter(proxyGettersAndSetters[i].toLowerCase().replace(/s$/, ''), proxyGettersAndSetters[i]);
+    }
+
+    // add shortcut for year (uses different syntax than the getter/setter 'year' == 'FullYear')
+    makeGetterAndSetter('year', 'FullYear');
+
+    // add plural methods
+    moment.fn.days = moment.fn.day;
+    moment.fn.weeks = moment.fn.week;
+    moment.fn.isoWeeks = moment.fn.isoWeek;
+
+    /************************************
+        Duration Prototype
+    ************************************/
+
+
+    moment.duration.fn = Duration.prototype = {
+        weeks : function () {
+            return absRound(this.days() / 7);
+        },
+
+        valueOf : function () {
+            return this._milliseconds +
+              this._days * 864e5 +
+              this._months * 2592e6;
+        },
+
+        humanize : function (withSuffix) {
+            var difference = +this,
+                output = relativeTime(difference, !withSuffix, this.lang());
+
+            if (withSuffix) {
+                output = this.lang().pastFuture(difference, output);
+            }
+
+            return this.lang().postformat(output);
+        },
+
+        lang : moment.fn.lang
+    };
+
+    function makeDurationGetter(name) {
+        moment.duration.fn[name] = function () {
+            return this._data[name];
+        };
+    }
+
+    function makeDurationAsGetter(name, factor) {
+        moment.duration.fn['as' + name] = function () {
+            return +this / factor;
+        };
+    }
+
+    for (i in unitMillisecondFactors) {
+        if (unitMillisecondFactors.hasOwnProperty(i)) {
+            makeDurationAsGetter(i, unitMillisecondFactors[i]);
+            makeDurationGetter(i.toLowerCase());
+        }
+    }
+
+    makeDurationAsGetter('Weeks', 6048e5);
+
+
+    /************************************
+        Default Lang
+    ************************************/
+
+
+    // Set default language, other languages will inherit from English.
+    moment.lang('en', {
+        ordinal : function (number) {
+            var b = number % 10,
+                output = (~~ (number % 100 / 10) === 1) ? 'th' :
+                (b === 1) ? 'st' :
+                (b === 2) ? 'nd' :
+                (b === 3) ? 'rd' : 'th';
+            return number + output;
+        }
+    });
+
+
+    /************************************
+        Exposing Moment
+    ************************************/
+
+
+    // CommonJS module is defined
+    if (hasModule) {
+        module.exports = moment;
+    }
+    /*global ender:false */
+    if (typeof ender === 'undefined') {
+        // here, `this` means `window` in the browser, or `global` on the server
+        // add `moment` as a global object via a string identifier,
+        // for Closure Compiler "advanced" mode
+        this['moment'] = moment;
+    }
+    /*global define:false */
+    if (typeof define === "function" && define.amd) {
+        define("moment", [], function () {
+            return moment;
+        });
+    }
+}).call(this);
+
+})()
+},{}],6:[function(require,module,exports){
+(function(global){/**
+ * @license
+ * Lo-Dash 1.2.1 (Custom Build) <http://lodash.com/>
+ * Build: `lodash modern -o ./dist/lodash.js`
+ * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
+ * Based on Underscore.js 1.4.4 <http://underscorejs.org/>
+ * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * Available under MIT license <http://lodash.com/license>
+ */
+;(function(window) {
+
+  /** Used as a safe reference for `undefined` in pre ES5 environments */
+  var undefined;
+
+  /** Detect free variable `exports` */
+  var freeExports = typeof exports == 'object' && exports;
+
+  /** Detect free variable `module` */
+  var freeModule = typeof module == 'object' && module && module.exports == freeExports && module;
+
+  /** Detect free variable `global`, from Node.js or Browserified code, and use it as `window` */
+  var freeGlobal = typeof global == 'object' && global;
+  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+    window = freeGlobal;
+  }
+
+  /** Used to generate unique IDs */
+  var idCounter = 0;
+
+  /** Used internally to indicate various things */
+  var indicatorObject = {};
+
+  /** 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 = 200;
+
+  /** 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 */
+  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
+
+  /**
+   * Used to match ES6 template delimiters
+   * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6
+   */
+  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
+
+  /** Used to match regexp flags from their coerced string values */
+  var reFlags = /\w*$/;
+
+  /** Used to match "interpolate" template delimiters */
+  var reInterpolate = /<%=([\s\S]+?)%>/g;
+
+  /** 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 leading whitespace and zeros to be removed */
+  var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');
+
+  /** Used to ensure capturing order of template delimiters */
+  var reNoMatch = /($^)/;
+
+  /** Used to match HTML characters */
+  var reUnescapedHtml = /[&<>"']/g;
+
+  /** 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',
+    'setImmediate', '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 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'
+  };
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Create a new `lodash` function using the given `context` object.
+   *
+   * @static
+   * @memberOf _
+   * @category Utilities
+   * @param {Object} [context=window] 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.com/#x11.1.5.
+    context = context ? _.defaults(window.Object(), context, _.pick(window, contextProps)) : window;
+
+    /** 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` and `Object` method references */
+    var arrayRef = Array(),
+        objectRef = Object();
+
+    /** Used to restore the original `_` reference in `noConflict` */
+    var oldDash = context._;
+
+    /** Used to detect if a method is native */
+    var reNative = RegExp('^' +
+      String(objectRef.valueOf)
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/valueOf|for [^\]]+/g, '.+?') + '$'
+    );
+
+    /** Native method shortcuts */
+    var ceil = Math.ceil,
+        clearTimeout = context.clearTimeout,
+        concat = arrayRef.concat,
+        floor = Math.floor,
+        getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,
+        hasOwnProperty = objectRef.hasOwnProperty,
+        push = arrayRef.push,
+        setImmediate = context.setImmediate,
+        setTimeout = context.setTimeout,
+        toString = objectRef.toString;
+
+    /* Native method shortcuts for methods with the same name as other `lodash` methods */
+    var nativeBind = reNative.test(nativeBind = toString.bind) && nativeBind,
+        nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,
+        nativeIsFinite = context.isFinite,
+        nativeIsNaN = context.isNaN,
+        nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys,
+        nativeMax = Math.max,
+        nativeMin = Math.min,
+        nativeParseInt = context.parseInt,
+        nativeRandom = Math.random,
+        nativeSlice = arrayRef.slice;
+
+    /** Detect various environments */
+    var isIeOpera = reNative.test(context.attachEvent),
+        isV8 = nativeBind && !/\n|true/.test(nativeBind + isIeOpera);
+
+    /** Used to lookup a built-in constructor by [[Class]] */
+    var ctorByClass = {};
+    ctorByClass[arrayClass] = Array;
+    ctorByClass[boolClass] = Boolean;
+    ctorByClass[dateClass] = Date;
+    ctorByClass[objectClass] = Object;
+    ctorByClass[numberClass] = Number;
+    ctorByClass[regexpClass] = RegExp;
+    ctorByClass[stringClass] = String;
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates a `lodash` object, which wraps the given `value`, to enable 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`
+     *
+     * Chaining is supported in custom builds as long as the `value` method is
+     * implicitly or explicitly included in the build.
+     *
+     * The chainable wrapper functions are:
+     * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,
+     * `compose`, `concat`, `countBy`, `createCallback`, `debounce`, `defaults`,
+     * `defer`, `delay`, `difference`, `filter`, `flatten`, `forEach`, `forIn`,
+     * `forOwn`, `functions`, `groupBy`, `initial`, `intersection`, `invert`,
+     * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,
+     * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `push`, `range`,
+     * `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, `sortBy`, `splice`,
+     * `tap`, `throttle`, `times`, `toArray`, `union`, `uniq`, `unshift`, `unzip`,
+     * `values`, `where`, `without`, `wrap`, and `zip`
+     *
+     * The non-chainable wrapper functions are:
+     * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`,
+     * `identity`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`,
+     * `isElement`, `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`,
+     * `isNull`, `isNumber`, `isObject`, `isPlainObject`, `isRegExp`, `isString`,
+     * `isUndefined`, `join`, `lastIndexOf`, `mixin`, `noConflict`, `parseInt`,
+     * `pop`, `random`, `reduce`, `reduceRight`, `result`, `shift`, `size`, `some`,
+     * `sortedIndex`, `runInContext`, `template`, `unescape`, `uniqueId`, and `value`
+     *
+     * The wrapper functions `first` and `last` return wrapped values when `n` is
+     * passed, otherwise they return unwrapped values.
+     *
+     * @name _
+     * @constructor
+     * @category Chaining
+     * @param {Mixed} value The value to wrap in a `lodash` instance.
+     * @returns {Object} Returns a `lodash` instance.
+     * @example
+     *
+     * var wrapped = _([1, 2, 3]);
+     *
+     * // returns an unwrapped value
+     * wrapped.reduce(function(sum, num) {
+     *   return sum + num;
+     * });
+     * // => 6
+     *
+     * // returns a wrapped value
+     * var squares = wrapped.map(function(num) {
+     *   return num * num;
+     * });
+     *
+     * _.isArray(squares);
+     * // => false
+     *
+     * _.isArray(squares.value());
+     * // => true
+     */
+    function lodash(value) {
+      // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor
+      return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))
+       ? value
+       : new lodashWrapper(value);
+    }
+
+    /**
+     * An object used to flag environments features.
+     *
+     * @static
+     * @memberOf _
+     * @type Object
+     */
+    var support = lodash.support = {};
+
+    /**
+     * Detect if `Function#bind` exists and is inferred to be fast (all but V8).
+     *
+     * @memberOf _.support
+     * @type Boolean
+     */
+    support.fastBind = nativeBind && !isV8;
+
+    /**
+     * By default, the template delimiters used by Lo-Dash are similar to those in
+     * embedded Ruby (ERB). Change the following template settings to use alternative
+     * delimiters.
+     *
+     * @static
+     * @memberOf _
+     * @type Object
+     */
+    lodash.templateSettings = {
+
+      /**
+       * Used to detect `data` property values to be HTML-escaped.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'escape': /<%-([\s\S]+?)%>/g,
+
+      /**
+       * Used to detect code to be evaluated.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'evaluate': /<%([\s\S]+?)%>/g,
+
+      /**
+       * Used to detect `data` property values to inject.
+       *
+       * @memberOf _.templateSettings
+       * @type RegExp
+       */
+      'interpolate': reInterpolate,
+
+      /**
+       * Used to reference the data object in the template text.
+       *
+       * @memberOf _.templateSettings
+       * @type String
+       */
+      'variable': '',
+
+      /**
+       * Used to import variables into the compiled template.
+       *
+       * @memberOf _.templateSettings
+       * @type Object
+       */
+      'imports': {
+
+        /**
+         * A reference to the `lodash` function.
+         *
+         * @memberOf _.templateSettings.imports
+         * @type Function
+         */
+        '_': lodash
+      }
+    };
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates a function optimized to search large arrays for a given `value`,
+     * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`.
+     *
+     * @private
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @returns {Boolean} Returns `true`, if `value` is found, else `false`.
+     */
+    function cachedContains(array) {
+      var length = array.length,
+          isLarge = length >= largeArraySize;
+
+      if (isLarge) {
+        var cache = {},
+            index = -1;
+
+        while (++index < length) {
+          var key = keyPrefix + array[index];
+          (cache[key] || (cache[key] = [])).push(array[index]);
+        }
+      }
+      return function(value) {
+        if (isLarge) {
+          var key = keyPrefix + value;
+          return  cache[key] && indexOf(cache[key], value) > -1;
+        }
+        return indexOf(array, value) > -1;
+      }
+    }
+
+    /**
+     * 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` values, 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 ai = a.index,
+          bi = b.index;
+
+      a = a.criteria;
+      b = b.criteria;
+
+      // ensure a stable sort in V8 and other engines
+      // http://code.google.com/p/v8/issues/detail?id=90
+      if (a !== b) {
+        if (a > b || typeof a == 'undefined') {
+          return 1;
+        }
+        if (a < b || typeof b == 'undefined') {
+          return -1;
+        }
+      }
+      return ai < bi ? -1 : 1;
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with the `this` binding
+     * of `thisArg` and prepends any `partialArgs` to the arguments passed to the
+     * bound function.
+     *
+     * @private
+     * @param {Function|String} func The function to bind or the method name.
+     * @param {Mixed} [thisArg] The `this` binding of `func`.
+     * @param {Array} partialArgs An array of arguments to be partially applied.
+     * @param {Object} [idicator] Used to indicate binding by key or partially
+     *  applying arguments from the right.
+     * @returns {Function} Returns the new bound function.
+     */
+    function createBound(func, thisArg, partialArgs, indicator) {
+      var isFunc = isFunction(func),
+          isPartial = !partialArgs,
+          key = thisArg;
+
+      // juggle arguments
+      if (isPartial) {
+        var rightIndicator = indicator;
+        partialArgs = thisArg;
+      }
+      else if (!isFunc) {
+        if (!indicator) {
+          throw new TypeError;
+        }
+        thisArg = func;
+      }
+
+      function bound() {
+        // `Function#bind` spec
+        // http://es5.github.com/#x15.3.4.5
+        var args = arguments,
+            thisBinding = isPartial ? this : thisArg;
+
+        if (!isFunc) {
+          func = thisArg[key];
+        }
+        if (partialArgs.length) {
+          args = args.length
+            ? (args = nativeSlice.call(args), rightIndicator ? args.concat(partialArgs) : partialArgs.concat(args))
+            : partialArgs;
+        }
+        if (this instanceof bound) {
+          // ensure `new bound` is an instance of `func`
+          noop.prototype = func.prototype;
+          thisBinding = new noop;
+          noop.prototype = null;
+
+          // mimic the constructor's `return` behavior
+          // http://es5.github.com/#x13.2.2
+          var result = func.apply(thisBinding, args);
+          return isObject(result) ? result : thisBinding;
+        }
+        return func.apply(thisBinding, args);
+      }
+      return bound;
+    }
+
+    /**
+     * 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];
+    }
+
+    /**
+     * Used by `escape` to convert characters to HTML entities.
+     *
+     * @private
+     * @param {String} match The matched character to escape.
+     * @returns {String} Returns the escaped character.
+     */
+    function escapeHtmlChar(match) {
+      return htmlEscapes[match];
+    }
+
+    /**
+     * A fast path for creating `lodash` wrapper objects.
+     *
+     * @private
+     * @param {Mixed} value The value to wrap in a `lodash` instance.
+     * @returns {Object} Returns a `lodash` instance.
+     */
+    function lodashWrapper(value) {
+      this.__wrapped__ = value;
+    }
+    // ensure `new lodashWrapper` is an instance of `lodash`
+    lodashWrapper.prototype = lodash.prototype;
+
+    /**
+     * A no-operation function.
+     *
+     * @private
+     */
+    function noop() {
+      // no operation performed
+    }
+
+    /**
+     * A fallback implementation of `isPlainObject` which checks if a given `value`
+     * is an object created by the `Object` constructor, assuming objects created
+     * by the `Object` constructor have no inherited enumerable properties and that
+     * there are no `Object.prototype` extensions.
+     *
+     * @private
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
+     */
+    function shimIsPlainObject(value) {
+      // avoid non-objects and false positives for `arguments` objects
+      var result = false;
+      if (!(value && toString.call(value) == objectClass)) {
+        return result;
+      }
+      // check that the constructor is `Object` (i.e. `Object instanceof Object`)
+      var ctor = value.constructor;
+
+      if (isFunction(ctor) ? ctor instanceof ctor : true) {
+        // In most environments an object's own properties are iterated before
+        // its inherited properties. If the last iterated property is an object's
+        // own property then there are no inherited enumerable properties.
+        forIn(value, function(value, key) {
+          result = key;
+        });
+        return result === false || hasOwnProperty.call(value, result);
+      }
+      return result;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Used by `unescape` to convert HTML entities to characters.
+     *
+     * @private
+     * @param {String} match The matched character to unescape.
+     * @returns {String} Returns the unescaped character.
+     */
+    function unescapeHtmlChar(match) {
+      return htmlUnescapes[match];
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Checks if `value` is an `arguments` object.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an `arguments` object, else `false`.
+     * @example
+     *
+     * (function() { return _.isArguments(arguments); })(1, 2, 3);
+     * // => true
+     *
+     * _.isArguments([1, 2, 3]);
+     * // => false
+     */
+    function isArguments(value) {
+      return toString.call(value) == argsClass;
+    }
+
+    /**
+     * Checks if `value` is an array.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an array, else `false`.
+     * @example
+     *
+     * (function() { return _.isArray(arguments); })();
+     * // => false
+     *
+     * _.isArray([1, 2, 3]);
+     * // => true
+     */
+    var isArray = nativeIsArray;
+
+    /**
+     * A fallback implementation of `Object.keys` which produces an array of the
+     * given object's own enumerable property names.
+     *
+     * @private
+     * @type Function
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names.
+     */
+    var shimKeys = function (object) {
+      var index, iterable = object, result = [];
+      if (!iterable) return result;
+      if (!(objectTypes[typeof object])) return result;
+
+        for (index in iterable) {
+          if (hasOwnProperty.call(iterable, index)) {    
+          result.push(index);    
+          }
+        }    
+      return result
+    };
+
+    /**
+     * Creates an array composed of the own enumerable property names of `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names.
+     * @example
+     *
+     * _.keys({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => ['one', 'two', 'three'] (order is not guaranteed)
+     */
+    var keys = !nativeKeys ? shimKeys : function(object) {
+      if (!isObject(object)) {
+        return [];
+      }
+      return nativeKeys(object);
+    };
+
+    /**
+     * Used to convert characters to HTML entities:
+     *
+     * Though the `>` character is escaped for symmetry, characters like `>` and `/`
+     * don't require escaping in HTML and have no special meaning unless they're part
+     * of a tag or an unquoted attribute value.
+     * http://mathiasbynens.be/notes/ambiguous-ampersands (under "semi-related fun fact")
+     */
+    var htmlEscapes = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;'
+    };
+
+    /** Used to convert HTML entities to characters */
+    var htmlUnescapes = invert(htmlEscapes);
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Assigns own enumerable properties of source object(s) to the destination
+     * object. Subsequent sources will overwrite property assignments of previous
+     * sources. If a `callback` function is passed, it will be executed to produce
+     * the assigned values. The `callback` is bound to `thisArg` and invoked with
+     * two arguments; (objectValue, sourceValue).
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @alias extend
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param {Function} [callback] The function to customize assigning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * _.assign({ 'name': 'moe' }, { 'age': 40 });
+     * // => { 'name': 'moe', 'age': 40 }
+     *
+     * var defaults = _.partialRight(_.assign, function(a, b) {
+     *   return typeof a == 'undefined' ? b : a;
+     * });
+     *
+     * var food = { 'name': 'apple' };
+     * defaults(food, { 'name': 'banana', 'type': 'fruit' });
+     * // => { 'name': 'apple', 'type': 'fruit' }
+     */
+    var assign = function (object, source, guard) {
+      var index, iterable = object, result = iterable;
+      if (!iterable) return result;
+      var args = arguments,
+          argsIndex = 0,
+          argsLength = typeof guard == 'number' ? 2 : args.length;
+      if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {
+        var callback = lodash.createCallback(args[--argsLength - 1], args[argsLength--], 2);
+      } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {
+        callback = args[--argsLength];
+      }
+      while (++argsIndex < argsLength) {
+        iterable = args[argsIndex];
+        if (iterable && objectTypes[typeof iterable]) {;
+      var length = iterable.length; index = -1;
+      if (isArray(iterable)) {
+        while (++index < length) {
+          result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]
+        }
+      }
+      else {    
+        var ownIndex = -1,
+            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],
+            length = ownProps.length;
+
+        while (++ownIndex < length) {
+          index = ownProps[ownIndex];
+          result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]
+        }    
+      }
+        }
+      };
+      return result
+    };
+
+    /**
+     * Creates a clone of `value`. If `deep` is `true`, nested objects will also
+     * be cloned, otherwise they will be assigned by reference. If a `callback`
+     * function is passed, it will be executed to produce the cloned values. If
+     * `callback` returns `undefined`, cloning will be handled by the method instead.
+     * The `callback` is bound to `thisArg` and invoked with one argument; (value).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to clone.
+     * @param {Boolean} [deep=false] A flag to indicate a deep clone.
+     * @param {Function} [callback] The function to customize cloning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Array} [stackA=[]] Tracks traversed source objects.
+     * @param- {Array} [stackB=[]] Associates clones with source counterparts.
+     * @returns {Mixed} Returns the cloned `value`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * var shallow = _.clone(stooges);
+     * shallow[0] === stooges[0];
+     * // => true
+     *
+     * var deep = _.clone(stooges, true);
+     * deep[0] === stooges[0];
+     * // => false
+     *
+     * _.mixin({
+     *   'clone': _.partialRight(_.clone, function(value) {
+     *     return _.isElement(value) ? value.cloneNode(false) : undefined;
+     *   })
+     * });
+     *
+     * var clone = _.clone(document.body);
+     * clone.childNodes.length;
+     * // => 0
+     */
+    function clone(value, deep, callback, thisArg, stackA, stackB) {
+      var result = value;
+
+      // allows working with "Collections" methods without using their `callback`
+      // argument, `index|key`, for this method's `callback`
+      if (typeof deep == 'function') {
+        thisArg = callback;
+        callback = deep;
+        deep = false;
+      }
+      if (typeof callback == 'function') {
+        callback = (typeof thisArg == 'undefined')
+          ? callback
+          : lodash.createCallback(callback, thisArg, 1);
+
+        result = callback(result);
+        if (typeof result != 'undefined') {
+          return result;
+        }
+        result = value;
+      }
+      // inspect [[Class]]
+      var isObj = isObject(result);
+      if (isObj) {
+        var className = toString.call(result);
+        if (!cloneableClasses[className]) {
+          return result;
+        }
+        var isArr = isArray(result);
+      }
+      // shallow clone
+      if (!isObj || !deep) {
+        return isObj
+          ? (isArr ? slice(result) : assign({}, result))
+          : result;
+      }
+      var ctor = ctorByClass[className];
+      switch (className) {
+        case boolClass:
+        case dateClass:
+          return new ctor(+result);
+
+        case numberClass:
+        case stringClass:
+          return new ctor(result);
+
+        case regexpClass:
+          return ctor(result.source, reFlags.exec(result));
+      }
+      // check for circular references and return corresponding clone
+      stackA || (stackA = []);
+      stackB || (stackB = []);
+
+      var length = stackA.length;
+      while (length--) {
+        if (stackA[length] == value) {
+          return stackB[length];
+        }
+      }
+      // init cloned object
+      result = isArr ? ctor(result.length) : {};
+
+      // add array properties assigned by `RegExp#exec`
+      if (isArr) {
+        if (hasOwnProperty.call(value, 'index')) {
+          result.index = value.index;
+        }
+        if (hasOwnProperty.call(value, 'input')) {
+          result.input = value.input;
+        }
+      }
+      // add the source value to the stack of traversed objects
+      // and associate it with its clone
+      stackA.push(value);
+      stackB.push(result);
+
+      // recursively populate clone (susceptible to call stack limits)
+      (isArr ? forEach : forOwn)(value, function(objValue, key) {
+        result[key] = clone(objValue, deep, callback, undefined, stackA, stackB);
+      });
+
+      return result;
+    }
+
+    /**
+     * Creates a deep clone of `value`. If a `callback` function is passed,
+     * it will be executed to produce the cloned values. If `callback` returns
+     * `undefined`, cloning will be handled by the method instead. The `callback`
+     * is bound to `thisArg` and invoked with one argument; (value).
+     *
+     * Note: This function is loosely based on the structured clone algorithm. Functions
+     * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and
+     * objects created by constructors other than `Object` are cloned to plain `Object` objects.
+     * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to deep clone.
+     * @param {Function} [callback] The function to customize cloning values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the deep cloned `value`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * var deep = _.cloneDeep(stooges);
+     * deep[0] === stooges[0];
+     * // => false
+     *
+     * var view = {
+     *   'label': 'docs',
+     *   'node': element
+     * };
+     *
+     * var clone = _.cloneDeep(view, function(value) {
+     *   return _.isElement(value) ? value.cloneNode(true) : undefined;
+     * });
+     *
+     * clone.node == view.node;
+     * // => false
+     */
+    function cloneDeep(value, callback, thisArg) {
+      return clone(value, true, callback, thisArg);
+    }
+
+    /**
+     * Assigns own enumerable properties of source object(s) to the destination
+     * object for all destination properties that resolve to `undefined`. Once a
+     * property is set, additional defaults of the same property will be ignored.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param- {Object} [guard] Allows working with `_.reduce` without using its
+     *  callback's `key` and `object` arguments as sources.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * var food = { 'name': 'apple' };
+     * _.defaults(food, { 'name': 'banana', 'type': 'fruit' });
+     * // => { 'name': 'apple', 'type': 'fruit' }
+     */
+    var defaults = function (object, source, guard) {
+      var index, iterable = object, result = iterable;
+      if (!iterable) return result;
+      var args = arguments,
+          argsIndex = 0,
+          argsLength = typeof guard == 'number' ? 2 : args.length;
+      while (++argsIndex < argsLength) {
+        iterable = args[argsIndex];
+        if (iterable && objectTypes[typeof iterable]) {;
+      var length = iterable.length; index = -1;
+      if (isArray(iterable)) {
+        while (++index < length) {
+          if (typeof result[index] == 'undefined') result[index] = iterable[index]
+        }
+      }
+      else {    
+        var ownIndex = -1,
+            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],
+            length = ownProps.length;
+
+        while (++ownIndex < length) {
+          index = ownProps[ownIndex];
+          if (typeof result[index] == 'undefined') result[index] = iterable[index]
+        }    
+      }
+        }
+      };
+      return result
+    };
+
+    /**
+     * This method is similar to `_.find`, except that it returns the key of the
+     * element that passes the callback check, instead of the element itself.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to search.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the key of the found element, else `undefined`.
+     * @example
+     *
+     * _.findKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {
+     *   return num % 2 == 0;
+     * });
+     * // => 'b'
+     */
+    function findKey(object, callback, thisArg) {
+      var result;
+      callback = lodash.createCallback(callback, thisArg);
+      forOwn(object, function(value, key, object) {
+        if (callback(value, key, object)) {
+          result = key;
+          return false;
+        }
+      });
+      return result;
+    }
+
+    /**
+     * Iterates over `object`'s own and inherited enumerable properties, executing
+     * the `callback` for each property. The `callback` is bound to `thisArg` and
+     * invoked with three arguments; (value, key, object). Callbacks may exit iteration
+     * early by explicitly returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The object to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * function Dog(name) {
+     *   this.name = name;
+     * }
+     *
+     * Dog.prototype.bark = function() {
+     *   alert('Woof, woof!');
+     * };
+     *
+     * _.forIn(new Dog('Dagny'), function(value, key) {
+     *   alert(key);
+     * });
+     * // => alerts 'name' and 'bark' (order is not guaranteed)
+     */
+    var forIn = function (collection, callback, thisArg) {
+      var index, iterable = collection, result = iterable;
+      if (!iterable) return result;
+      if (!objectTypes[typeof iterable]) return result;
+      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);
+
+        for (index in iterable) {
+          if (callback(iterable[index], index, collection) === false) return result;    
+        }    
+      return result
+    };
+
+    /**
+     * Iterates over an object's own enumerable properties, executing the `callback`
+     * for each property. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, key, object). Callbacks may exit iteration early by explicitly
+     * returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Objects
+     * @param {Object} object The object to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {
+     *   alert(key);
+     * });
+     * // => alerts '0', '1', and 'length' (order is not guaranteed)
+     */
+    var forOwn = function (collection, callback, thisArg) {
+      var index, iterable = collection, result = iterable;
+      if (!iterable) return result;
+      if (!objectTypes[typeof iterable]) return result;
+      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);
+
+        var ownIndex = -1,
+            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],
+            length = ownProps.length;
+
+        while (++ownIndex < length) {
+          index = ownProps[ownIndex];
+          if (callback(iterable[index], index, collection) === false) return result
+        }    
+      return result
+    };
+
+    /**
+     * Creates a sorted array of all enumerable properties, own and inherited,
+     * of `object` that have function values.
+     *
+     * @static
+     * @memberOf _
+     * @alias methods
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property names that have function values.
+     * @example
+     *
+     * _.functions(_);
+     * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]
+     */
+    function functions(object) {
+      var result = [];
+      forIn(object, function(value, key) {
+        if (isFunction(value)) {
+          result.push(key);
+        }
+      });
+      return result.sort();
+    }
+
+    /**
+     * Checks if the specified object `property` exists and is a direct property,
+     * instead of an inherited property.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to check.
+     * @param {String} property The property to check for.
+     * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
+     * @example
+     *
+     * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');
+     * // => true
+     */
+    function has(object, property) {
+      return object ? hasOwnProperty.call(object, property) : false;
+    }
+
+    /**
+     * Creates an object composed of the inverted keys and values of the given `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to invert.
+     * @returns {Object} Returns the created inverted object.
+     * @example
+     *
+     *  _.invert({ 'first': 'moe', 'second': 'larry' });
+     * // => { 'moe': 'first', 'larry': 'second' }
+     */
+    function invert(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = {};
+
+      while (++index < length) {
+        var key = props[index];
+        result[object[key]] = key;
+      }
+      return result;
+    }
+
+    /**
+     * Checks if `value` is a boolean value.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a boolean value, else `false`.
+     * @example
+     *
+     * _.isBoolean(null);
+     * // => false
+     */
+    function isBoolean(value) {
+      return value === true || value === false || toString.call(value) == boolClass;
+    }
+
+    /**
+     * Checks if `value` is a date.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a date, else `false`.
+     * @example
+     *
+     * _.isDate(new Date);
+     * // => true
+     */
+    function isDate(value) {
+      return value ? (typeof value == 'object' && toString.call(value) == dateClass) : false;
+    }
+
+    /**
+     * Checks if `value` is a DOM element.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a DOM element, else `false`.
+     * @example
+     *
+     * _.isElement(document.body);
+     * // => true
+     */
+    function isElement(value) {
+      return value ? value.nodeType === 1 : false;
+    }
+
+    /**
+     * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
+     * length of `0` and objects with no own enumerable properties are considered
+     * "empty".
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Array|Object|String} value The value to inspect.
+     * @returns {Boolean} Returns `true`, if the `value` is empty, else `false`.
+     * @example
+     *
+     * _.isEmpty([1, 2, 3]);
+     * // => false
+     *
+     * _.isEmpty({});
+     * // => true
+     *
+     * _.isEmpty('');
+     * // => true
+     */
+    function isEmpty(value) {
+      var result = true;
+      if (!value) {
+        return result;
+      }
+      var className = toString.call(value),
+          length = value.length;
+
+      if ((className == arrayClass || className == stringClass || className == argsClass ) ||
+          (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {
+        return !length;
+      }
+      forOwn(value, function() {
+        return (result = false);
+      });
+      return result;
+    }
+
+    /**
+     * Performs a deep comparison between two values to determine if they are
+     * equivalent to each other. If `callback` is passed, it will be executed to
+     * compare values. If `callback` returns `undefined`, comparisons will be handled
+     * by the method instead. The `callback` is bound to `thisArg` and invoked with
+     * two arguments; (a, b).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} a The value to compare.
+     * @param {Mixed} b The other value to compare.
+     * @param {Function} [callback] The function to customize comparing values.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Array} [stackA=[]] Tracks traversed `a` objects.
+     * @param- {Array} [stackB=[]] Tracks traversed `b` objects.
+     * @returns {Boolean} Returns `true`, if the values are equivalent, else `false`.
+     * @example
+     *
+     * var moe = { 'name': 'moe', 'age': 40 };
+     * var copy = { 'name': 'moe', 'age': 40 };
+     *
+     * moe == copy;
+     * // => false
+     *
+     * _.isEqual(moe, copy);
+     * // => true
+     *
+     * var words = ['hello', 'goodbye'];
+     * var otherWords = ['hi', 'goodbye'];
+     *
+     * _.isEqual(words, otherWords, function(a, b) {
+     *   var reGreet = /^(?:hello|hi)$/i,
+     *       aGreet = _.isString(a) && reGreet.test(a),
+     *       bGreet = _.isString(b) && reGreet.test(b);
+     *
+     *   return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;
+     * });
+     * // => true
+     */
+    function isEqual(a, b, callback, thisArg, stackA, stackB) {
+      // used to indicate that when comparing objects, `a` has at least the properties of `b`
+      var whereIndicator = callback === indicatorObject;
+      if (typeof callback == 'function' && !whereIndicator) {
+        callback = lodash.createCallback(callback, thisArg, 2);
+        var result = callback(a, b);
+        if (typeof result != 'undefined') {
+          return !!result;
+        }
+      }
+      // exit early for identical values
+      if (a === b) {
+        // treat `+0` vs. `-0` as not equal
+        return a !== 0 || (1 / a == 1 / b);
+      }
+      var type = typeof a,
+          otherType = typeof b;
+
+      // exit early for unlike primitive values
+      if (a === a &&
+          (!a || (type != 'function' && type != 'object')) &&
+          (!b || (otherType != 'function' && otherType != 'object'))) {
+        return false;
+      }
+      // exit early for `null` and `undefined`, avoiding ES3's Function#call behavior
+      // http://es5.github.com/#x15.3.4.4
+      if (a == null || b == null) {
+        return a === b;
+      }
+      // compare [[Class]] names
+      var className = toString.call(a),
+          otherClass = toString.call(b);
+
+      if (className == argsClass) {
+        className = objectClass;
+      }
+      if (otherClass == argsClass) {
+        otherClass = objectClass;
+      }
+      if (className != otherClass) {
+        return false;
+      }
+      switch (className) {
+        case boolClass:
+        case dateClass:
+          // coerce dates and booleans to numbers, dates to milliseconds and booleans
+          // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal
+          return +a == +b;
+
+        case numberClass:
+          // treat `NaN` vs. `NaN` as equal
+          return (a != +a)
+            ? b != +b
+            // but treat `+0` vs. `-0` as not equal
+            : (a == 0 ? (1 / a == 1 / b) : a == +b);
+
+        case regexpClass:
+        case stringClass:
+          // coerce regexes to strings (http://es5.github.com/#x15.10.6.4)
+          // treat string primitives and their corresponding object instances as equal
+          return a == String(b);
+      }
+      var isArr = className == arrayClass;
+      if (!isArr) {
+        // unwrap any `lodash` wrapped values
+        if (hasOwnProperty.call(a, '__wrapped__ ') || hasOwnProperty.call(b, '__wrapped__')) {
+          return isEqual(a.__wrapped__ || a, b.__wrapped__ || b, callback, thisArg, stackA, stackB);
+        }
+        // exit for functions and DOM nodes
+        if (className != objectClass) {
+          return false;
+        }
+        // in older versions of Opera, `arguments` objects have `Array` constructors
+        var ctorA = a.constructor,
+            ctorB = b.constructor;
+
+        // non `Object` object instances with different constructors are not equal
+        if (ctorA != ctorB && !(
+              isFunction(ctorA) && ctorA instanceof ctorA &&
+              isFunction(ctorB) && ctorB instanceof ctorB
+            )) {
+          return false;
+        }
+      }
+      // assume cyclic structures are equal
+      // the algorithm for detecting cyclic structures is adapted from ES 5.1
+      // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)
+      stackA || (stackA = []);
+      stackB || (stackB = []);
+
+      var length = stackA.length;
+      while (length--) {
+        if (stackA[length] == a) {
+          return stackB[length] == b;
+        }
+      }
+      var size = 0;
+      result = true;
+
+      // add `a` and `b` to the stack of traversed objects
+      stackA.push(a);
+      stackB.push(b);
+
+      // recursively compare objects and arrays (susceptible to call stack limits)
+      if (isArr) {
+        length = a.length;
+        size = b.length;
+
+        // compare lengths to determine if a deep comparison is necessary
+        result = size == a.length;
+        if (!result && !whereIndicator) {
+          return result;
+        }
+        // deep compare the contents, ignoring non-numeric properties
+        while (size--) {
+          var index = length,
+              value = b[size];
+
+          if (whereIndicator) {
+            while (index--) {
+              if ((result = isEqual(a[index], value, callback, thisArg, stackA, stackB))) {
+                break;
+              }
+            }
+          } else if (!(result = isEqual(a[size], value, callback, thisArg, stackA, stackB))) {
+            break;
+          }
+        }
+        return result;
+      }
+      // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`
+      // which, in this case, is more costly
+      forIn(b, function(value, key, b) {
+        if (hasOwnProperty.call(b, key)) {
+          // count the number of properties.
+          size++;
+          // deep compare each property value.
+          return (result = hasOwnProperty.call(a, key) && isEqual(a[key], value, callback, thisArg, stackA, stackB));
+        }
+      });
+
+      if (result && !whereIndicator) {
+        // ensure both objects have the same number of properties
+        forIn(a, function(value, key, a) {
+          if (hasOwnProperty.call(a, key)) {
+            // `size` will be `-1` if `a` has more properties than `b`
+            return (result = --size > -1);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Checks if `value` is, or can be coerced to, a finite number.
+     *
+     * Note: This is not the same as native `isFinite`, which will return true for
+     * booleans and empty strings. See http://es5.github.com/#x15.1.2.5.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is finite, else `false`.
+     * @example
+     *
+     * _.isFinite(-101);
+     * // => true
+     *
+     * _.isFinite('10');
+     * // => true
+     *
+     * _.isFinite(true);
+     * // => false
+     *
+     * _.isFinite('');
+     * // => false
+     *
+     * _.isFinite(Infinity);
+     * // => false
+     */
+    function isFinite(value) {
+      return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));
+    }
+
+    /**
+     * Checks if `value` is a function.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a function, else `false`.
+     * @example
+     *
+     * _.isFunction(_);
+     * // => true
+     */
+    function isFunction(value) {
+      return typeof value == 'function';
+    }
+
+    /**
+     * Checks if `value` is the language type of Object.
+     * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is an object, else `false`.
+     * @example
+     *
+     * _.isObject({});
+     * // => true
+     *
+     * _.isObject([1, 2, 3]);
+     * // => true
+     *
+     * _.isObject(1);
+     * // => false
+     */
+    function isObject(value) {
+      // check if the value is the ECMAScript language type of Object
+      // http://es5.github.com/#x8
+      // and avoid a V8 bug
+      // http://code.google.com/p/v8/issues/detail?id=2291
+      return value ? objectTypes[typeof value] : false;
+    }
+
+    /**
+     * Checks if `value` is `NaN`.
+     *
+     * Note: This is not the same as native `isNaN`, which will return `true` for
+     * `undefined` and other values. See http://es5.github.com/#x15.1.2.4.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `NaN`, else `false`.
+     * @example
+     *
+     * _.isNaN(NaN);
+     * // => true
+     *
+     * _.isNaN(new Number(NaN));
+     * // => true
+     *
+     * isNaN(undefined);
+     * // => true
+     *
+     * _.isNaN(undefined);
+     * // => false
+     */
+    function isNaN(value) {
+      // `NaN` as a primitive is the only value that is not equal to itself
+      // (perform the [[Class]] check first to avoid errors with some host objects in IE)
+      return isNumber(value) && value != +value
+    }
+
+    /**
+     * Checks if `value` is `null`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `null`, else `false`.
+     * @example
+     *
+     * _.isNull(null);
+     * // => true
+     *
+     * _.isNull(undefined);
+     * // => false
+     */
+    function isNull(value) {
+      return value === null;
+    }
+
+    /**
+     * Checks if `value` is a number.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a number, else `false`.
+     * @example
+     *
+     * _.isNumber(8.4 * 5);
+     * // => true
+     */
+    function isNumber(value) {
+      return typeof value == 'number' || toString.call(value) == numberClass;
+    }
+
+    /**
+     * Checks if a given `value` is an object created by the `Object` constructor.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.
+     * @example
+     *
+     * function Stooge(name, age) {
+     *   this.name = name;
+     *   this.age = age;
+     * }
+     *
+     * _.isPlainObject(new Stooge('moe', 40));
+     * // => false
+     *
+     * _.isPlainObject([1, 2, 3]);
+     * // => false
+     *
+     * _.isPlainObject({ 'name': 'moe', 'age': 40 });
+     * // => true
+     */
+    var isPlainObject = function(value) {
+      if (!(value && toString.call(value) == objectClass)) {
+        return false;
+      }
+      var valueOf = value.valueOf,
+          objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);
+
+      return objProto
+        ? (value == objProto || getPrototypeOf(value) == objProto)
+        : shimIsPlainObject(value);
+    };
+
+    /**
+     * Checks if `value` is a regular expression.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a regular expression, else `false`.
+     * @example
+     *
+     * _.isRegExp(/moe/);
+     * // => true
+     */
+    function isRegExp(value) {
+      return value ? (typeof value == 'object' && toString.call(value) == regexpClass) : false;
+    }
+
+    /**
+     * Checks if `value` is a string.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is a string, else `false`.
+     * @example
+     *
+     * _.isString('moe');
+     * // => true
+     */
+    function isString(value) {
+      return typeof value == 'string' || toString.call(value) == stringClass;
+    }
+
+    /**
+     * Checks if `value` is `undefined`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Mixed} value The value to check.
+     * @returns {Boolean} Returns `true`, if the `value` is `undefined`, else `false`.
+     * @example
+     *
+     * _.isUndefined(void 0);
+     * // => true
+     */
+    function isUndefined(value) {
+      return typeof value == 'undefined';
+    }
+
+    /**
+     * Recursively merges own enumerable properties of the source object(s), that
+     * don't resolve to `undefined`, into the destination object. Subsequent sources
+     * will overwrite property assignments of previous sources. If a `callback` function
+     * is passed, it will be executed to produce the merged values of the destination
+     * and source properties. If `callback` returns `undefined`, merging will be
+     * handled by the method instead. The `callback` is bound to `thisArg` and
+     * invoked with two arguments; (objectValue, sourceValue).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The destination object.
+     * @param {Object} [source1, source2, ...] The source objects.
+     * @param {Function} [callback] The function to customize merging properties.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @param- {Object} [deepIndicator] Indicates that `stackA` and `stackB` are
+     *  arrays of traversed objects, instead of source objects.
+     * @param- {Array} [stackA=[]] Tracks traversed source objects.
+     * @param- {Array} [stackB=[]] Associates values with source counterparts.
+     * @returns {Object} Returns the destination object.
+     * @example
+     *
+     * var names = {
+     *   'stooges': [
+     *     { 'name': 'moe' },
+     *     { 'name': 'larry' }
+     *   ]
+     * };
+     *
+     * var ages = {
+     *   'stooges': [
+     *     { 'age': 40 },
+     *     { 'age': 50 }
+     *   ]
+     * };
+     *
+     * _.merge(names, ages);
+     * // => { 'stooges': [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] }
+     *
+     * var food = {
+     *   'fruits': ['apple'],
+     *   'vegetables': ['beet']
+     * };
+     *
+     * var otherFood = {
+     *   'fruits': ['banana'],
+     *   'vegetables': ['carrot']
+     * };
+     *
+     * _.merge(food, otherFood, function(a, b) {
+     *   return _.isArray(a) ? a.concat(b) : undefined;
+     * });
+     * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }
+     */
+    function merge(object, source, deepIndicator) {
+      var args = arguments,
+          index = 0,
+          length = 2;
+
+      if (!isObject(object)) {
+        return object;
+      }
+      if (deepIndicator === indicatorObject) {
+        var callback = args[3],
+            stackA = args[4],
+            stackB = args[5];
+      } else {
+        stackA = [];
+        stackB = [];
+
+        // allows working with `_.reduce` and `_.reduceRight` without
+        // using their `callback` arguments, `index|key` and `collection`
+        if (typeof deepIndicator != 'number') {
+          length = args.length;
+        }
+        if (length > 3 && typeof args[length - 2] == 'function') {
+          callback = lodash.createCallback(args[--length - 1], args[length--], 2);
+        } else if (length > 2 && typeof args[length - 1] == 'function') {
+          callback = args[--length];
+        }
+      }
+      while (++index < length) {
+        (isArray(args[index]) ? forEach : forOwn)(args[index], function(source, key) {
+          var found,
+              isArr,
+              result = source,
+              value = object[key];
+
+          if (source && ((isArr = isArray(source)) || isPlainObject(source))) {
+            // avoid merging previously merged cyclic sources
+            var stackLength = stackA.length;
+            while (stackLength--) {
+              if ((found = stackA[stackLength] == source)) {
+                value = stackB[stackLength];
+                break;
+              }
+            }
+            if (!found) {
+              var isShallow;
+              if (callback) {
+                result = callback(value, source);
+                if ((isShallow = typeof result != 'undefined')) {
+                  value = result;
+                }
+              }
+              if (!isShallow) {
+                value = isArr
+                  ? (isArray(value) ? value : [])
+                  : (isPlainObject(value) ? value : {});
+              }
+              // add `source` and associated `value` to the stack of traversed objects
+              stackA.push(source);
+              stackB.push(value);
+
+              // recursively merge objects and arrays (susceptible to call stack limits)
+              if (!isShallow) {
+                value = merge(value, source, indicatorObject, callback, stackA, stackB);
+              }
+            }
+          }
+          else {
+            if (callback) {
+              result = callback(value, source);
+              if (typeof result == 'undefined') {
+                result = source;
+              }
+            }
+            if (typeof result != 'undefined') {
+              value = result;
+            }
+          }
+          object[key] = value;
+        });
+      }
+      return object;
+    }
+
+    /**
+     * Creates a shallow clone of `object` excluding the specified properties.
+     * Property names may be specified as individual arguments or as arrays of
+     * property names. If a `callback` function is passed, it will be executed
+     * for each property in the `object`, omitting the properties `callback`
+     * returns truthy for. The `callback` is bound to `thisArg` and invoked
+     * with three arguments; (value, key, object).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The source object.
+     * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit
+     *  or the function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns an object without the omitted properties.
+     * @example
+     *
+     * _.omit({ 'name': 'moe', 'age': 40 }, 'age');
+     * // => { 'name': 'moe' }
+     *
+     * _.omit({ 'name': 'moe', 'age': 40 }, function(value) {
+     *   return typeof value == 'number';
+     * });
+     * // => { 'name': 'moe' }
+     */
+    function omit(object, callback, thisArg) {
+      var isFunc = typeof callback == 'function',
+          result = {};
+
+      if (isFunc) {
+        callback = lodash.createCallback(callback, thisArg);
+      } else {
+        var props = concat.apply(arrayRef, nativeSlice.call(arguments, 1));
+      }
+      forIn(object, function(value, key, object) {
+        if (isFunc
+              ? !callback(value, key, object)
+              : indexOf(props, key) < 0
+            ) {
+          result[key] = value;
+        }
+      });
+      return result;
+    }
+
+    /**
+     * Creates a two dimensional array of the given object's key-value pairs,
+     * i.e. `[[key1, value1], [key2, value2]]`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns new array of key-value pairs.
+     * @example
+     *
+     * _.pairs({ 'moe': 30, 'larry': 40 });
+     * // => [['moe', 30], ['larry', 40]] (order is not guaranteed)
+     */
+    function pairs(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = Array(length);
+
+      while (++index < length) {
+        var key = props[index];
+        result[index] = [key, object[key]];
+      }
+      return result;
+    }
+
+    /**
+     * Creates a shallow clone of `object` composed of the specified properties.
+     * Property names may be specified as individual arguments or as arrays of property
+     * names. If `callback` is passed, it will be executed for each property in the
+     * `object`, picking the properties `callback` returns truthy for. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, key, object).
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The source object.
+     * @param {Array|Function|String} callback|[prop1, prop2, ...] The function called
+     *  per iteration or properties to pick, either as individual arguments or arrays.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns an object composed of the picked properties.
+     * @example
+     *
+     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');
+     * // => { 'name': 'moe' }
+     *
+     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) {
+     *   return key.charAt(0) != '_';
+     * });
+     * // => { 'name': 'moe' }
+     */
+    function pick(object, callback, thisArg) {
+      var result = {};
+      if (typeof callback != 'function') {
+        var index = -1,
+            props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
+            length = isObject(object) ? props.length : 0;
+
+        while (++index < length) {
+          var key = props[index];
+          if (key in object) {
+            result[key] = object[key];
+          }
+        }
+      } else {
+        callback = lodash.createCallback(callback, thisArg);
+        forIn(object, function(value, key, object) {
+          if (callback(value, key, object)) {
+            result[key] = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array composed of the own enumerable property values of `object`.
+     *
+     * @static
+     * @memberOf _
+     * @category Objects
+     * @param {Object} object The object to inspect.
+     * @returns {Array} Returns a new array of property values.
+     * @example
+     *
+     * _.values({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => [1, 2, 3] (order is not guaranteed)
+     */
+    function values(object) {
+      var index = -1,
+          props = keys(object),
+          length = props.length,
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = object[props[index]];
+      }
+      return result;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates an array of elements from the specified indexes, or keys, of the
+     * `collection`. Indexes may be specified as individual arguments or as arrays
+     * of indexes.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Array|Number|String} [index1, index2, ...] The indexes of
+     *  `collection` to retrieve, either as individual arguments or arrays.
+     * @returns {Array} Returns a new array of elements corresponding to the
+     *  provided indexes.
+     * @example
+     *
+     * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);
+     * // => ['a', 'c', 'e']
+     *
+     * _.at(['moe', 'larry', 'curly'], 0, 2);
+     * // => ['moe', 'curly']
+     */
+    function at(collection) {
+      var index = -1,
+          props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
+          length = props.length,
+          result = Array(length);
+
+      while(++index < length) {
+        result[index] = collection[props[index]];
+      }
+      return result;
+    }
+
+    /**
+     * Checks if a given `target` element is present in a `collection` using strict
+     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+     * as the offset from the end of the collection.
+     *
+     * @static
+     * @memberOf _
+     * @alias include
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Mixed} target The value to check for.
+     * @param {Number} [fromIndex=0] The index to search from.
+     * @returns {Boolean} Returns `true` if the `target` element is found, else `false`.
+     * @example
+     *
+     * _.contains([1, 2, 3], 1);
+     * // => true
+     *
+     * _.contains([1, 2, 3], 1, 2);
+     * // => false
+     *
+     * _.contains({ 'name': 'moe', 'age': 40 }, 'moe');
+     * // => true
+     *
+     * _.contains('curly', 'ur');
+     * // => true
+     */
+    function contains(collection, target, fromIndex) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = false;
+
+      fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;
+      if (typeof length == 'number') {
+        result = (isString(collection)
+          ? collection.indexOf(target, fromIndex)
+          : indexOf(collection, target, fromIndex)
+        ) > -1;
+      } else {
+        forOwn(collection, function(value) {
+          if (++index >= fromIndex) {
+            return !(result = value === target);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Creates an object composed of keys returned from running each element of the
+     * `collection` through the given `callback`. The corresponding value of each key
+     * is the number of times the key was returned by the `callback`. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the composed aggregate object.
+     * @example
+     *
+     * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });
+     * // => { '4': 1, '6': 2 }
+     *
+     * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+     * // => { '4': 1, '6': 2 }
+     *
+     * _.countBy(['one', 'two', 'three'], 'length');
+     * // => { '3': 2, '5': 1 }
+     */
+    function countBy(collection, callback, thisArg) {
+      var result = {};
+      callback = lodash.createCallback(callback, thisArg);
+
+      forEach(collection, function(value, key, collection) {
+        key = String(callback(value, key, collection));
+        (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);
+      });
+      return result;
+    }
+
+    /**
+     * Checks if the `callback` returns a truthy value for **all** elements of a
+     * `collection`. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias all
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Boolean} Returns `true` if all elements pass the callback check,
+     *  else `false`.
+     * @example
+     *
+     * _.every([true, 1, null, 'yes'], Boolean);
+     * // => false
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.every(stooges, 'age');
+     * // => true
+     *
+     * // using "_.where" callback shorthand
+     * _.every(stooges, { 'age': 50 });
+     * // => false
+     */
+    function every(collection, callback, thisArg) {
+      var result = true;
+      callback = lodash.createCallback(callback, thisArg);
+
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      if (typeof length == 'number') {
+        while (++index < length) {
+          if (!(result = !!callback(collection[index], index, collection))) {
+            break;
+          }
+        }
+      } else {
+        forOwn(collection, function(value, index, collection) {
+          return (result = !!callback(value, index, collection));
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Examines each element in a `collection`, returning an array of all elements
+     * the `callback` returns truthy for. The `callback` is bound to `thisArg` and
+     * invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias select
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of elements that passed the callback check.
+     * @example
+     *
+     * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+     * // => [2, 4, 6]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.filter(food, 'organic');
+     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]
+     *
+     * // using "_.where" callback shorthand
+     * _.filter(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]
+     */
+    function filter(collection, callback, thisArg) {
+      var result = [];
+      callback = lodash.createCallback(callback, thisArg);
+
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      if (typeof length == 'number') {
+        while (++index < length) {
+          var value = collection[index];
+          if (callback(value, index, collection)) {
+            result.push(value);
+          }
+        }
+      } else {
+        forOwn(collection, function(value, index, collection) {
+          if (callback(value, index, collection)) {
+            result.push(value);
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Examines each element in a `collection`, returning the first that the `callback`
+     * returns truthy for. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias detect
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the found element, else `undefined`.
+     * @example
+     *
+     * _.find([1, 2, 3, 4], function(num) {
+     *   return num % 2 == 0;
+     * });
+     * // => 2
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'banana', 'organic': true,  'type': 'fruit' },
+     *   { 'name': 'beet',   'organic': false, 'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.find(food, { 'type': 'vegetable' });
+     * // => { 'name': 'beet', 'organic': false, 'type': 'vegetable' }
+     *
+     * // using "_.pluck" callback shorthand
+     * _.find(food, 'organic');
+     * // => { 'name': 'banana', 'organic': true, 'type': 'fruit' }
+     */
+    function find(collection, callback, thisArg) {
+      callback = lodash.createCallback(callback, thisArg);
+
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      if (typeof length == 'number') {
+        while (++index < length) {
+          var value = collection[index];
+          if (callback(value, index, collection)) {
+            return value;
+          }
+        }
+      } else {
+        var result;
+        forOwn(collection, function(value, index, collection) {
+          if (callback(value, index, collection)) {
+            result = value;
+            return false;
+          }
+        });
+        return result;
+      }
+    }
+
+    /**
+     * Iterates over a `collection`, executing the `callback` for each element in
+     * the `collection`. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection). Callbacks may exit iteration early
+     * by explicitly returning `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias each
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array|Object|String} Returns `collection`.
+     * @example
+     *
+     * _([1, 2, 3]).forEach(alert).join(',');
+     * // => alerts each number and returns '1,2,3'
+     *
+     * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert);
+     * // => alerts each number value (order is not guaranteed)
+     */
+    function forEach(collection, callback, thisArg) {
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);
+      if (typeof length == 'number') {
+        while (++index < length) {
+          if (callback(collection[index], index, collection) === false) {
+            break;
+          }
+        }
+      } else {
+        forOwn(collection, callback);
+      }
+      return collection;
+    }
+
+    /**
+     * Creates an object composed of keys returned from running each element of the
+     * `collection` through the `callback`. The corresponding value of each key is
+     * an array of elements passed to `callback` that returned the key. The `callback`
+     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Object} Returns the composed aggregate object.
+     * @example
+     *
+     * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });
+     * // => { '4': [4.2], '6': [6.1, 6.4] }
+     *
+     * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);
+     * // => { '4': [4.2], '6': [6.1, 6.4] }
+     *
+     * // using "_.pluck" callback shorthand
+     * _.groupBy(['one', 'two', 'three'], 'length');
+     * // => { '3': ['one', 'two'], '5': ['three'] }
+     */
+    function groupBy(collection, callback, thisArg) {
+      var result = {};
+      callback = lodash.createCallback(callback, thisArg);
+
+      forEach(collection, function(value, key, collection) {
+        key = String(callback(value, key, collection));
+        (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);
+      });
+      return result;
+    }
+
+    /**
+     * Invokes the method named by `methodName` on each element in the `collection`,
+     * returning an array of the results of each invoked method. Additional arguments
+     * will be passed to each invoked method. If `methodName` is a function, it will
+     * be invoked for, and `this` bound to, each element in the `collection`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|String} methodName The name of the method to invoke or
+     *  the function invoked per iteration.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+     * @returns {Array} Returns a new array of the results of each invoked method.
+     * @example
+     *
+     * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+     * // => [[1, 5, 7], [1, 2, 3]]
+     *
+     * _.invoke([123, 456], String.prototype.split, '');
+     * // => [['1', '2', '3'], ['4', '5', '6']]
+     */
+    function invoke(collection, methodName) {
+      var args = nativeSlice.call(arguments, 2),
+          index = -1,
+          isFunc = typeof methodName == 'function',
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      forEach(collection, function(value) {
+        result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);
+      });
+      return result;
+    }
+
+    /**
+     * Creates an array of values by running each element in the `collection`
+     * through the `callback`. The `callback` is bound to `thisArg` and invoked with
+     * three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias collect
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of the results of each `callback` execution.
+     * @example
+     *
+     * _.map([1, 2, 3], function(num) { return num * 3; });
+     * // => [3, 6, 9]
+     *
+     * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });
+     * // => [3, 6, 9] (order is not guaranteed)
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.map(stooges, 'name');
+     * // => ['moe', 'larry']
+     */
+    function map(collection, callback, thisArg) {
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      callback = lodash.createCallback(callback, thisArg);
+      if (typeof length == 'number') {
+        var result = Array(length);
+        while (++index < length) {
+          result[index] = callback(collection[index], index, collection);
+        }
+      } else {
+        result = [];
+        forOwn(collection, function(value, key, collection) {
+          result[++index] = callback(value, key, collection);
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the maximum value of an `array`. If `callback` is passed,
+     * it will be executed for each value in the `array` to generate the
+     * criterion by which the value is ranked. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the maximum value.
+     * @example
+     *
+     * _.max([4, 2, 8, 6]);
+     * // => 8
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.max(stooges, function(stooge) { return stooge.age; });
+     * // => { 'name': 'larry', 'age': 50 };
+     *
+     * // using "_.pluck" callback shorthand
+     * _.max(stooges, 'age');
+     * // => { 'name': 'larry', 'age': 50 };
+     */
+    function max(collection, callback, thisArg) {
+      var computed = -Infinity,
+          result = computed;
+
+      if (!callback && isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          var value = collection[index];
+          if (value > result) {
+            result = value;
+          }
+        }
+      } else {
+        callback = (!callback && isString(collection))
+          ? charAtCallback
+          : lodash.createCallback(callback, thisArg);
+
+        forEach(collection, function(value, index, collection) {
+          var current = callback(value, index, collection);
+          if (current > computed) {
+            computed = current;
+            result = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the minimum value of an `array`. If `callback` is passed,
+     * it will be executed for each value in the `array` to generate the
+     * criterion by which the value is ranked. The `callback` is bound to `thisArg`
+     * and invoked with three arguments; (value, index, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the minimum value.
+     * @example
+     *
+     * _.min([4, 2, 8, 6]);
+     * // => 2
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.min(stooges, function(stooge) { return stooge.age; });
+     * // => { 'name': 'moe', 'age': 40 };
+     *
+     * // using "_.pluck" callback shorthand
+     * _.min(stooges, 'age');
+     * // => { 'name': 'moe', 'age': 40 };
+     */
+    function min(collection, callback, thisArg) {
+      var computed = Infinity,
+          result = computed;
+
+      if (!callback && isArray(collection)) {
+        var index = -1,
+            length = collection.length;
+
+        while (++index < length) {
+          var value = collection[index];
+          if (value < result) {
+            result = value;
+          }
+        }
+      } else {
+        callback = (!callback && isString(collection))
+          ? charAtCallback
+          : lodash.createCallback(callback, thisArg);
+
+        forEach(collection, function(value, index, collection) {
+          var current = callback(value, index, collection);
+          if (current < computed) {
+            computed = current;
+            result = value;
+          }
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Retrieves the value of a specified property from all elements in the `collection`.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {String} property The property to pluck.
+     * @returns {Array} Returns a new array of property values.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.pluck(stooges, 'name');
+     * // => ['moe', 'larry']
+     */
+    function pluck(collection, property) {
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      if (typeof length == 'number') {
+        var result = Array(length);
+        while (++index < length) {
+          result[index] = collection[index][property];
+        }
+      }
+      return result || map(collection, property);
+    }
+
+    /**
+     * Reduces a `collection` to a value which is the accumulated result of running
+     * each element in the `collection` through the `callback`, where each successive
+     * `callback` execution consumes the return value of the previous execution.
+     * If `accumulator` is not passed, the first element of the `collection` will be
+     * used as the initial `accumulator` value. The `callback` is bound to `thisArg`
+     * and invoked with four arguments; (accumulator, value, index|key, collection).
+     *
+     * @static
+     * @memberOf _
+     * @alias foldl, inject
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [accumulator] Initial value of the accumulator.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the accumulated value.
+     * @example
+     *
+     * var sum = _.reduce([1, 2, 3], function(sum, num) {
+     *   return sum + num;
+     * });
+     * // => 6
+     *
+     * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {
+     *   result[key] = num * 3;
+     *   return result;
+     * }, {});
+     * // => { 'a': 3, 'b': 6, 'c': 9 }
+     */
+    function reduce(collection, callback, accumulator, thisArg) {
+      if (!collection) return accumulator;
+      var noaccum = arguments.length < 3;
+      callback = lodash.createCallback(callback, thisArg, 4);
+
+      var index = -1,
+          length = collection.length;
+
+      if (typeof length == 'number') {
+        if (noaccum) {
+          accumulator = collection[++index];
+        }
+        while (++index < length) {
+          accumulator = callback(accumulator, collection[index], index, collection);
+        }
+      } else {
+        forOwn(collection, function(value, index, collection) {
+          accumulator = noaccum
+            ? (noaccum = false, value)
+            : callback(accumulator, value, index, collection)
+        });
+      }
+      return accumulator;
+    }
+
+    /**
+     * This method is similar to `_.reduce`, except that it iterates over a
+     * `collection` from right to left.
+     *
+     * @static
+     * @memberOf _
+     * @alias foldr
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function} [callback=identity] The function called per iteration.
+     * @param {Mixed} [accumulator] Initial value of the accumulator.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the accumulated value.
+     * @example
+     *
+     * var list = [[0, 1], [2, 3], [4, 5]];
+     * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);
+     * // => [4, 5, 2, 3, 0, 1]
+     */
+    function reduceRight(collection, callback, accumulator, thisArg) {
+      var iterable = collection,
+          length = collection ? collection.length : 0,
+          noaccum = arguments.length < 3;
+
+      if (typeof length != 'number') {
+        var props = keys(collection);
+        length = props.length;
+      }
+      callback = lodash.createCallback(callback, thisArg, 4);
+      forEach(collection, function(value, index, collection) {
+        index = props ? props[--length] : --length;
+        accumulator = noaccum
+          ? (noaccum = false, iterable[index])
+          : callback(accumulator, iterable[index], index, collection);
+      });
+      return accumulator;
+    }
+
+    /**
+     * The opposite of `_.filter`, this method returns the elements of a
+     * `collection` that `callback` does **not** return truthy for.
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of elements that did **not** pass the
+     *  callback check.
+     * @example
+     *
+     * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });
+     * // => [1, 3, 5]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.reject(food, 'organic');
+     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]
+     *
+     * // using "_.where" callback shorthand
+     * _.reject(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]
+     */
+    function reject(collection, callback, thisArg) {
+      callback = lodash.createCallback(callback, thisArg);
+      return filter(collection, function(value, index, collection) {
+        return !callback(value, index, collection);
+      });
+    }
+
+    /**
+     * Creates an array of shuffled `array` values, using a version of the
+     * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to shuffle.
+     * @returns {Array} Returns a new shuffled collection.
+     * @example
+     *
+     * _.shuffle([1, 2, 3, 4, 5, 6]);
+     * // => [4, 1, 6, 3, 5, 2]
+     */
+    function shuffle(collection) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      forEach(collection, function(value) {
+        var rand = floor(nativeRandom() * (++index + 1));
+        result[index] = result[rand];
+        result[rand] = value;
+      });
+      return result;
+    }
+
+    /**
+     * Gets the size of the `collection` by returning `collection.length` for arrays
+     * and array-like objects or the number of own enumerable properties for objects.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to inspect.
+     * @returns {Number} Returns `collection.length` or number of own enumerable properties.
+     * @example
+     *
+     * _.size([1, 2]);
+     * // => 2
+     *
+     * _.size({ 'one': 1, 'two': 2, 'three': 3 });
+     * // => 3
+     *
+     * _.size('curly');
+     * // => 5
+     */
+    function size(collection) {
+      var length = collection ? collection.length : 0;
+      return typeof length == 'number' ? length : keys(collection).length;
+    }
+
+    /**
+     * Checks if the `callback` returns a truthy value for **any** element of a
+     * `collection`. The function returns as soon as it finds passing value, and
+     * does not iterate over the entire `collection`. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias any
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Boolean} Returns `true` if any element passes the callback check,
+     *  else `false`.
+     * @example
+     *
+     * _.some([null, 0, 'yes', false], Boolean);
+     * // => true
+     *
+     * var food = [
+     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },
+     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.some(food, 'organic');
+     * // => true
+     *
+     * // using "_.where" callback shorthand
+     * _.some(food, { 'type': 'meat' });
+     * // => false
+     */
+    function some(collection, callback, thisArg) {
+      var result;
+      callback = lodash.createCallback(callback, thisArg);
+
+      var index = -1,
+          length = collection ? collection.length : 0;
+
+      if (typeof length == 'number') {
+        while (++index < length) {
+          if ((result = callback(collection[index], index, collection))) {
+            break;
+          }
+        }
+      } else {
+        forOwn(collection, function(value, index, collection) {
+          return !(result = callback(value, index, collection));
+        });
+      }
+      return !!result;
+    }
+
+    /**
+     * Creates an array of elements, sorted in ascending order by the results of
+     * running each element in the `collection` through the `callback`. This method
+     * performs a stable sort, that is, it will preserve the original sort order of
+     * equal elements. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index|key, collection).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of sorted elements.
+     * @example
+     *
+     * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });
+     * // => [3, 1, 2]
+     *
+     * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);
+     * // => [3, 1, 2]
+     *
+     * // using "_.pluck" callback shorthand
+     * _.sortBy(['banana', 'strawberry', 'apple'], 'length');
+     * // => ['apple', 'banana', 'strawberry']
+     */
+    function sortBy(collection, callback, thisArg) {
+      var index = -1,
+          length = collection ? collection.length : 0,
+          result = Array(typeof length == 'number' ? length : 0);
+
+      callback = lodash.createCallback(callback, thisArg);
+      forEach(collection, function(value, key, collection) {
+        result[++index] = {
+          'criteria': callback(value, key, collection),
+          'index': index,
+          'value': value
+        };
+      });
+
+      length = result.length;
+      result.sort(compareAscending);
+      while (length--) {
+        result[length] = result[length].value;
+      }
+      return result;
+    }
+
+    /**
+     * Converts the `collection` to an array.
+     *
+     * @static
+     * @memberOf _
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to convert.
+     * @returns {Array} Returns the new converted array.
+     * @example
+     *
+     * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+     * // => [2, 3, 4]
+     */
+    function toArray(collection) {
+      if (collection && typeof collection.length == 'number') {
+        return slice(collection);
+      }
+      return values(collection);
+    }
+
+    /**
+     * Examines each element in a `collection`, returning an array of all elements
+     * that have the given `properties`. When checking `properties`, this method
+     * performs a deep comparison between values to determine if they are equivalent
+     * to each other.
+     *
+     * @static
+     * @memberOf _
+     * @type Function
+     * @category Collections
+     * @param {Array|Object|String} collection The collection to iterate over.
+     * @param {Object} properties The object of property values to filter by.
+     * @returns {Array} Returns a new array of elements that have the given `properties`.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * _.where(stooges, { 'age': 40 });
+     * // => [{ 'name': 'moe', 'age': 40 }]
+     */
+    var where = filter;
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Creates an array with all falsey values of `array` removed. The values
+     * `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to compact.
+     * @returns {Array} Returns a new filtered array.
+     * @example
+     *
+     * _.compact([0, 1, false, 2, '', 3]);
+     * // => [1, 2, 3]
+     */
+    function compact(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (value) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array of `array` elements not present in the other arrays
+     * using strict equality for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to process.
+     * @param {Array} [array1, array2, ...] Arrays to check.
+     * @returns {Array} Returns a new array of `array` elements not present in the
+     *  other arrays.
+     * @example
+     *
+     * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+     * // => [1, 3, 4]
+     */
+    function difference(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          flattened = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),
+          contains = cachedContains(flattened),
+          result = [];
+
+      while (++index < length) {
+        var value = array[index];
+        if (!contains(value)) {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * This method is similar to `_.find`, except that it returns the index of
+     * the element that passes the callback check, instead of the element itself.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to search.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the index of the found element, else `-1`.
+     * @example
+     *
+     * _.findIndex(['apple', 'banana', 'beet'], function(food) {
+     *   return /^b/.test(food);
+     * });
+     * // => 1
+     */
+    function findIndex(array, callback, thisArg) {
+      var index = -1,
+          length = array ? array.length : 0;
+
+      callback = lodash.createCallback(callback, thisArg);
+      while (++index < length) {
+        if (callback(array[index], index, array)) {
+          return index;
+        }
+      }
+      return -1;
+    }
+
+    /**
+     * Gets the first element of the `array`. If a number `n` is passed, the first
+     * `n` elements of the `array` are returned. If a `callback` function is passed,
+     * elements at the beginning of the array are returned as long as the `callback`
+     * returns truthy. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias head, take
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n] The function called
+     *  per element or the number of elements to return. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the first element(s) of `array`.
+     * @example
+     *
+     * _.first([1, 2, 3]);
+     * // => 1
+     *
+     * _.first([1, 2, 3], 2);
+     * // => [1, 2]
+     *
+     * _.first([1, 2, 3], function(num) {
+     *   return num < 3;
+     * });
+     * // => [1, 2]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'organic': true },
+     *   { 'name': 'beet',   'organic': false },
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.first(food, 'organic');
+     * // => [{ 'name': 'banana', 'organic': true }]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'type': 'fruit' },
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.first(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'apple', 'type': 'fruit' }, { 'name': 'banana', 'type': 'fruit' }]
+     */
+    function first(array, callback, thisArg) {
+      if (array) {
+        var n = 0,
+            length = array.length;
+
+        if (typeof callback != 'number' && callback != null) {
+          var index = -1;
+          callback = lodash.createCallback(callback, thisArg);
+          while (++index < length && callback(array[index], index, array)) {
+            n++;
+          }
+        } else {
+          n = callback;
+          if (n == null || thisArg) {
+            return array[0];
+          }
+        }
+        return slice(array, 0, nativeMin(nativeMax(0, n), length));
+      }
+    }
+
+    /**
+     * Flattens a nested array (the nesting can be to any depth). If `isShallow`
+     * is truthy, `array` will only be flattened a single level. If `callback`
+     * is passed, each element of `array` is passed through a `callback` before
+     * flattening. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to flatten.
+     * @param {Boolean} [isShallow=false] A flag to indicate only flattening a single level.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new flattened array.
+     * @example
+     *
+     * _.flatten([1, [2], [3, [[4]]]]);
+     * // => [1, 2, 3, 4];
+     *
+     * _.flatten([1, [2], [3, [[4]]]], true);
+     * // => [1, 2, 3, [[4]]];
+     *
+     * var stooges = [
+     *   { 'name': 'curly', 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },
+     *   { 'name': 'moe', 'quotes': ['Spread out!', 'You knucklehead!'] }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.flatten(stooges, 'quotes');
+     * // => ['Oh, a wise guy, eh?', 'Poifect!', 'Spread out!', 'You knucklehead!']
+     */
+    function flatten(array, isShallow, callback, thisArg) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [];
+
+      // juggle arguments
+      if (typeof isShallow != 'boolean' && isShallow != null) {
+        thisArg = callback;
+        callback = isShallow;
+        isShallow = false;
+      }
+      if (callback != null) {
+        callback = lodash.createCallback(callback, thisArg);
+      }
+      while (++index < length) {
+        var value = array[index];
+        if (callback) {
+          value = callback(value, index, array);
+        }
+        // recursively flatten arrays (susceptible to call stack limits)
+        if (isArray(value)) {
+          push.apply(result, isShallow ? value : flatten(value));
+        } else {
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Gets the index at which the first occurrence of `value` is found using
+     * strict equality for comparisons, i.e. `===`. If the `array` is already
+     * sorted, passing `true` for `fromIndex` will run a faster binary search.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to
+     *  perform a binary search on a sorted `array`.
+     * @returns {Number} Returns the index of the matched value or `-1`.
+     * @example
+     *
+     * _.indexOf([1, 2, 3, 1, 2, 3], 2);
+     * // => 1
+     *
+     * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);
+     * // => 4
+     *
+     * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);
+     * // => 2
+     */
+    function indexOf(array, value, fromIndex) {
+      var index = -1,
+          length = array ? array.length : 0;
+
+      if (typeof fromIndex == 'number') {
+        index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1;
+      } else if (fromIndex) {
+        index = sortedIndex(array, value);
+        return array[index] === value ? index : -1;
+      }
+      while (++index < length) {
+        if (array[index] === value) {
+          return index;
+        }
+      }
+      return -1;
+    }
+
+    /**
+     * Gets all but the last element of `array`. If a number `n` is passed, the
+     * last `n` elements are excluded from the result. If a `callback` function
+     * is passed, elements at the end of the array are excluded from the result
+     * as long as the `callback` returns truthy. The `callback` is bound to
+     * `thisArg` and invoked with three arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n=1] The function called
+     *  per element or the number of elements to exclude. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a slice of `array`.
+     * @example
+     *
+     * _.initial([1, 2, 3]);
+     * // => [1, 2]
+     *
+     * _.initial([1, 2, 3], 2);
+     * // => [1]
+     *
+     * _.initial([1, 2, 3], function(num) {
+     *   return num > 1;
+     * });
+     * // => [1]
+     *
+     * var food = [
+     *   { 'name': 'beet',   'organic': false },
+     *   { 'name': 'carrot', 'organic': true }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.initial(food, 'organic');
+     * // => [{ 'name': 'beet',   'organic': false }]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' },
+     *   { 'name': 'carrot', 'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.initial(food, { 'type': 'vegetable' });
+     * // => [{ 'name': 'banana', 'type': 'fruit' }]
+     */
+    function initial(array, callback, thisArg) {
+      if (!array) {
+        return [];
+      }
+      var n = 0,
+          length = array.length;
+
+      if (typeof callback != 'number' && callback != null) {
+        var index = length;
+        callback = lodash.createCallback(callback, thisArg);
+        while (index-- && callback(array[index], index, array)) {
+          n++;
+        }
+      } else {
+        n = (callback == null || thisArg) ? 1 : callback || n;
+      }
+      return slice(array, 0, nativeMin(nativeMax(0, length - n), length));
+    }
+
+    /**
+     * Computes the intersection of all the passed-in arrays using strict equality
+     * for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of unique elements that are present
+     *  in **all** of the arrays.
+     * @example
+     *
+     * _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+     * // => [1, 2]
+     */
+    function intersection(array) {
+      var args = arguments,
+          argsLength = args.length,
+          cache = { '0': {} },
+          index = -1,
+          length = array ? array.length : 0,
+          isLarge = length >= largeArraySize,
+          result = [],
+          seen = result;
+
+      outer:
+      while (++index < length) {
+        var value = array[index];
+        if (isLarge) {
+          var key = keyPrefix + value;
+          var inited = cache[0][key]
+            ? !(seen = cache[0][key])
+            : (seen = cache[0][key] = []);
+        }
+        if (inited || indexOf(seen, value) < 0) {
+          if (isLarge) {
+            seen.push(value);
+          }
+          var argsIndex = argsLength;
+          while (--argsIndex) {
+            if (!(cache[argsIndex] || (cache[argsIndex] = cachedContains(args[argsIndex])))(value)) {
+              continue outer;
+            }
+          }
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Gets the last element of the `array`. If a number `n` is passed, the
+     * last `n` elements of the `array` are returned. If a `callback` function
+     * is passed, elements at the end of the array are returned as long as the
+     * `callback` returns truthy. The `callback` is bound to `thisArg` and
+     * invoked with three arguments;(value, index, array).
+     *
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n] The function called
+     *  per element or the number of elements to return. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Mixed} Returns the last element(s) of `array`.
+     * @example
+     *
+     * _.last([1, 2, 3]);
+     * // => 3
+     *
+     * _.last([1, 2, 3], 2);
+     * // => [2, 3]
+     *
+     * _.last([1, 2, 3], function(num) {
+     *   return num > 1;
+     * });
+     * // => [2, 3]
+     *
+     * var food = [
+     *   { 'name': 'beet',   'organic': false },
+     *   { 'name': 'carrot', 'organic': true }
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.last(food, 'organic');
+     * // => [{ 'name': 'carrot', 'organic': true }]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' },
+     *   { 'name': 'carrot', 'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.last(food, { 'type': 'vegetable' });
+     * // => [{ 'name': 'beet', 'type': 'vegetable' }, { 'name': 'carrot', 'type': 'vegetable' }]
+     */
+    function last(array, callback, thisArg) {
+      if (array) {
+        var n = 0,
+            length = array.length;
+
+        if (typeof callback != 'number' && callback != null) {
+          var index = length;
+          callback = lodash.createCallback(callback, thisArg);
+          while (index-- && callback(array[index], index, array)) {
+            n++;
+          }
+        } else {
+          n = callback;
+          if (n == null || thisArg) {
+            return array[length - 1];
+          }
+        }
+        return slice(array, nativeMax(0, length - n));
+      }
+    }
+
+    /**
+     * Gets the index at which the last occurrence of `value` is found using strict
+     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used
+     * as the offset from the end of the collection.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to search.
+     * @param {Mixed} value The value to search for.
+     * @param {Number} [fromIndex=array.length-1] The index to search from.
+     * @returns {Number} Returns the index of the matched value or `-1`.
+     * @example
+     *
+     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+     * // => 4
+     *
+     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);
+     * // => 1
+     */
+    function lastIndexOf(array, value, fromIndex) {
+      var index = array ? array.length : 0;
+      if (typeof fromIndex == 'number') {
+        index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;
+      }
+      while (index--) {
+        if (array[index] === value) {
+          return index;
+        }
+      }
+      return -1;
+    }
+
+    /**
+     * Creates an array of numbers (positive and/or negative) progressing from
+     * `start` up to but not including `end`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Number} [start=0] The start of the range.
+     * @param {Number} end The end of the range.
+     * @param {Number} [step=1] The value to increment or decrement by.
+     * @returns {Array} Returns a new range array.
+     * @example
+     *
+     * _.range(10);
+     * // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+     *
+     * _.range(1, 11);
+     * // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+     *
+     * _.range(0, 30, 5);
+     * // => [0, 5, 10, 15, 20, 25]
+     *
+     * _.range(0, -10, -1);
+     * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
+     *
+     * _.range(0);
+     * // => []
+     */
+    function range(start, end, step) {
+      start = +start || 0;
+      step = +step || 1;
+
+      if (end == null) {
+        end = start;
+        start = 0;
+      }
+      // use `Array(length)` so V8 will avoid the slower "dictionary" mode
+      // http://youtu.be/XAqIpGU8ZZk#t=17m25s
+      var index = -1,
+          length = nativeMax(0, ceil((end - start) / step)),
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = start;
+        start += step;
+      }
+      return result;
+    }
+
+    /**
+     * The opposite of `_.initial`, this method gets all but the first value of
+     * `array`. If a number `n` is passed, the first `n` values are excluded from
+     * the result. If a `callback` function is passed, elements at the beginning
+     * of the array are excluded from the result as long as the `callback` returns
+     * truthy. The `callback` is bound to `thisArg` and invoked with three
+     * arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias drop, tail
+     * @category Arrays
+     * @param {Array} array The array to query.
+     * @param {Function|Object|Number|String} [callback|n=1] The function called
+     *  per element or the number of elements to exclude. If a property name or
+     *  object is passed, it will be used to create a "_.pluck" or "_.where"
+     *  style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a slice of `array`.
+     * @example
+     *
+     * _.rest([1, 2, 3]);
+     * // => [2, 3]
+     *
+     * _.rest([1, 2, 3], 2);
+     * // => [3]
+     *
+     * _.rest([1, 2, 3], function(num) {
+     *   return num < 3;
+     * });
+     * // => [3]
+     *
+     * var food = [
+     *   { 'name': 'banana', 'organic': true },
+     *   { 'name': 'beet',   'organic': false },
+     * ];
+     *
+     * // using "_.pluck" callback shorthand
+     * _.rest(food, 'organic');
+     * // => [{ 'name': 'beet', 'organic': false }]
+     *
+     * var food = [
+     *   { 'name': 'apple',  'type': 'fruit' },
+     *   { 'name': 'banana', 'type': 'fruit' },
+     *   { 'name': 'beet',   'type': 'vegetable' }
+     * ];
+     *
+     * // using "_.where" callback shorthand
+     * _.rest(food, { 'type': 'fruit' });
+     * // => [{ 'name': 'beet', 'type': 'vegetable' }]
+     */
+    function rest(array, callback, thisArg) {
+      if (typeof callback != 'number' && callback != null) {
+        var n = 0,
+            index = -1,
+            length = array ? array.length : 0;
+
+        callback = lodash.createCallback(callback, thisArg);
+        while (++index < length && callback(array[index], index, array)) {
+          n++;
+        }
+      } else {
+        n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);
+      }
+      return slice(array, n);
+    }
+
+    /**
+     * Uses a binary search to determine the smallest index at which the `value`
+     * should be inserted into `array` in order to maintain the sort order of the
+     * sorted `array`. If `callback` is passed, it will be executed for `value` and
+     * each element in `array` to compute their sort ranking. The `callback` is
+     * bound to `thisArg` and invoked with one argument; (value).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to inspect.
+     * @param {Mixed} value The value to evaluate.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Number} Returns the index at which the value should be inserted
+     *  into `array`.
+     * @example
+     *
+     * _.sortedIndex([20, 30, 50], 40);
+     * // => 2
+     *
+     * // using "_.pluck" callback shorthand
+     * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');
+     * // => 2
+     *
+     * var dict = {
+     *   'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }
+     * };
+     *
+     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+     *   return dict.wordToNumber[word];
+     * });
+     * // => 2
+     *
+     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {
+     *   return this.wordToNumber[word];
+     * }, dict);
+     * // => 2
+     */
+    function sortedIndex(array, value, callback, thisArg) {
+      var low = 0,
+          high = array ? array.length : low;
+
+      // explicitly reference `identity` for better inlining in Firefox
+      callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;
+      value = callback(value);
+
+      while (low < high) {
+        var mid = (low + high) >>> 1;
+        (callback(array[mid]) < value)
+          ? low = mid + 1
+          : high = mid;
+      }
+      return low;
+    }
+
+    /**
+     * Computes the union of the passed-in arrays using strict equality for
+     * comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of unique values, in order, that are
+     *  present in one or more of the arrays.
+     * @example
+     *
+     * _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+     * // => [1, 2, 3, 101, 10]
+     */
+    function union(array) {
+      if (!isArray(array)) {
+        arguments[0] = array ? nativeSlice.call(array) : arrayRef;
+      }
+      return uniq(concat.apply(arrayRef, arguments));
+    }
+
+    /**
+     * Creates a duplicate-value-free version of the `array` using strict equality
+     * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`
+     * for `isSorted` will run a faster algorithm. If `callback` is passed, each
+     * element of `array` is passed through a `callback` before uniqueness is computed.
+     * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).
+     *
+     * If a property name is passed for `callback`, the created "_.pluck" style
+     * callback will return the property value of the given element.
+     *
+     * If an object is passed for `callback`, the created "_.where" style callback
+     * will return `true` for elements that have the properties of the given object,
+     * else `false`.
+     *
+     * @static
+     * @memberOf _
+     * @alias unique
+     * @category Arrays
+     * @param {Array} array The array to process.
+     * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted.
+     * @param {Function|Object|String} [callback=identity] The function called per
+     *  iteration. If a property name or object is passed, it will be used to create
+     *  a "_.pluck" or "_.where" style callback, respectively.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a duplicate-value-free array.
+     * @example
+     *
+     * _.uniq([1, 2, 1, 3, 1]);
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 1, 2, 2, 3], true);
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); });
+     * // => [1, 2, 3]
+     *
+     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math);
+     * // => [1, 2, 3]
+     *
+     * // using "_.pluck" callback shorthand
+     * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+     * // => [{ 'x': 1 }, { 'x': 2 }]
+     */
+    function uniq(array, isSorted, callback, thisArg) {
+      var index = -1,
+          length = array ? array.length : 0,
+          result = [],
+          seen = result;
+
+      // juggle arguments
+      if (typeof isSorted != 'boolean' && isSorted != null) {
+        thisArg = callback;
+        callback = isSorted;
+        isSorted = false;
+      }
+      // init value cache for large arrays
+      var isLarge = !isSorted && length >= largeArraySize;
+      if (isLarge) {
+        var cache = {};
+      }
+      if (callback != null) {
+        seen = [];
+        callback = lodash.createCallback(callback, thisArg);
+      }
+      while (++index < length) {
+        var value = array[index],
+            computed = callback ? callback(value, index, array) : value;
+
+        if (isLarge) {
+          var key = keyPrefix + computed;
+          var inited = cache[key]
+            ? !(seen = cache[key])
+            : (seen = cache[key] = []);
+        }
+        if (isSorted
+              ? !index || seen[seen.length - 1] !== computed
+              : inited || indexOf(seen, computed) < 0
+            ) {
+          if (callback || isLarge) {
+            seen.push(computed);
+          }
+          result.push(value);
+        }
+      }
+      return result;
+    }
+
+    /**
+     * The inverse of `_.zip`, this method splits groups of elements into arrays
+     * composed of elements from each group at their corresponding indexes.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to process.
+     * @returns {Array} Returns a new array of the composed arrays.
+     * @example
+     *
+     * _.unzip([['moe', 30, true], ['larry', 40, false]]);
+     * // => [['moe', 'larry'], [30, 40], [true, false]];
+     */
+    function unzip(array) {
+      var index = -1,
+          length = array ? array.length : 0,
+          tupleLength = length ? max(pluck(array, 'length')) : 0,
+          result = Array(tupleLength);
+
+      while (++index < length) {
+        var tupleIndex = -1,
+            tuple = array[index];
+
+        while (++tupleIndex < tupleLength) {
+          (result[tupleIndex] || (result[tupleIndex] = Array(length)))[index] = tuple[tupleIndex];
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Creates an array with all occurrences of the passed values removed using
+     * strict equality for comparisons, i.e. `===`.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} array The array to filter.
+     * @param {Mixed} [value1, value2, ...] Values to remove.
+     * @returns {Array} Returns a new filtered array.
+     * @example
+     *
+     * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+     * // => [2, 3, 4]
+     */
+    function without(array) {
+      return difference(array, nativeSlice.call(arguments, 1));
+    }
+
+    /**
+     * Groups the elements of each array at their corresponding indexes. Useful for
+     * separate data sources that are coordinated through matching array indexes.
+     * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix
+     * in a similar fashion.
+     *
+     * @static
+     * @memberOf _
+     * @category Arrays
+     * @param {Array} [array1, array2, ...] Arrays to process.
+     * @returns {Array} Returns a new array of grouped elements.
+     * @example
+     *
+     * _.zip(['moe', 'larry'], [30, 40], [true, false]);
+     * // => [['moe', 30, true], ['larry', 40, false]]
+     */
+    function zip(array) {
+      var index = -1,
+          length = array ? max(pluck(arguments, 'length')) : 0,
+          result = Array(length);
+
+      while (++index < length) {
+        result[index] = pluck(arguments, index);
+      }
+      return result;
+    }
+
+    /**
+     * Creates an object composed from arrays of `keys` and `values`. Pass either
+     * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or
+     * two arrays, one of `keys` and one of corresponding `values`.
+     *
+     * @static
+     * @memberOf _
+     * @alias object
+     * @category Arrays
+     * @param {Array} keys The array of keys.
+     * @param {Array} [values=[]] The array of values.
+     * @returns {Object} Returns an object composed of the given keys and
+     *  corresponding values.
+     * @example
+     *
+     * _.zipObject(['moe', 'larry'], [30, 40]);
+     * // => { 'moe': 30, 'larry': 40 }
+     */
+    function zipObject(keys, values) {
+      var index = -1,
+          length = keys ? keys.length : 0,
+          result = {};
+
+      while (++index < length) {
+        var key = keys[index];
+        if (values) {
+          result[key] = values[index];
+        } else {
+          result[key[0]] = key[1];
+        }
+      }
+      return result;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * If `n` is greater than `0`, a function is created that is restricted to
+     * executing `func`, with the `this` binding and arguments of the created
+     * function, only after it is called `n` times. If `n` is less than `1`,
+     * `func` is executed immediately, without a `this` binding or additional
+     * arguments, and its result is returned.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Number} n The number of times the function must be called before
+     * it is executed.
+     * @param {Function} func The function to restrict.
+     * @returns {Function} Returns the new restricted function.
+     * @example
+     *
+     * var renderNotes = _.after(notes.length, render);
+     * _.forEach(notes, function(note) {
+     *   note.asyncSave({ 'success': renderNotes });
+     * });
+     * // `renderNotes` is run once, after all notes have saved
+     */
+    function after(n, func) {
+      if (n < 1) {
+        return func();
+      }
+      return function() {
+        if (--n < 1) {
+          return func.apply(this, arguments);
+        }
+      };
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with the `this`
+     * binding of `thisArg` and prepends any additional `bind` arguments to those
+     * passed to the bound function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to bind.
+     * @param {Mixed} [thisArg] The `this` binding of `func`.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new bound function.
+     * @example
+     *
+     * var func = function(greeting) {
+     *   return greeting + ' ' + this.name;
+     * };
+     *
+     * func = _.bind(func, { 'name': 'moe' }, 'hi');
+     * func();
+     * // => 'hi moe'
+     */
+    function bind(func, thisArg) {
+      // use `Function#bind` if it exists and is fast
+      // (in V8 `Function#bind` is slower except when partially applied)
+      return support.fastBind || (nativeBind && arguments.length > 2)
+        ? nativeBind.call.apply(nativeBind, arguments)
+        : createBound(func, thisArg, nativeSlice.call(arguments, 2));
+    }
+
+    /**
+     * Binds methods on `object` to `object`, overwriting the existing method.
+     * Method names may be specified as individual arguments or as arrays of method
+     * names. If no method names are provided, all the function properties of `object`
+     * will be bound.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Object} object The object to bind and assign the bound methods to.
+     * @param {String} [methodName1, methodName2, ...] Method names on the object to bind.
+     * @returns {Object} Returns `object`.
+     * @example
+     *
+     * var view = {
+     *  'label': 'docs',
+     *  'onClick': function() { alert('clicked ' + this.label); }
+     * };
+     *
+     * _.bindAll(view);
+     * jQuery('#docs').on('click', view.onClick);
+     * // => alerts 'clicked docs', when the button is clicked
+     */
+    function bindAll(object) {
+      var funcs = arguments.length > 1 ? concat.apply(arrayRef, nativeSlice.call(arguments, 1)) : functions(object),
+          index = -1,
+          length = funcs.length;
+
+      while (++index < length) {
+        var key = funcs[index];
+        object[key] = bind(object[key], object);
+      }
+      return object;
+    }
+
+    /**
+     * Creates a function that, when called, invokes the method at `object[key]`
+     * and prepends any additional `bindKey` arguments to those passed to the bound
+     * function. This method differs from `_.bind` by allowing bound functions to
+     * reference methods that will be redefined or don't yet exist.
+     * See http://michaux.ca/articles/lazy-function-definition-pattern.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Object} object The object the method belongs to.
+     * @param {String} key The key of the method.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new bound function.
+     * @example
+     *
+     * var object = {
+     *   'name': 'moe',
+     *   'greet': function(greeting) {
+     *     return greeting + ' ' + this.name;
+     *   }
+     * };
+     *
+     * var func = _.bindKey(object, 'greet', 'hi');
+     * func();
+     * // => 'hi moe'
+     *
+     * object.greet = function(greeting) {
+     *   return greeting + ', ' + this.name + '!';
+     * };
+     *
+     * func();
+     * // => 'hi, moe!'
+     */
+    function bindKey(object, key) {
+      return createBound(object, key, nativeSlice.call(arguments, 2), indicatorObject);
+    }
+
+    /**
+     * Creates a function that is the composition of the passed functions,
+     * where each function consumes the return value of the function that follows.
+     * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+     * Each function is executed with the `this` binding of the composed function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} [func1, func2, ...] Functions to compose.
+     * @returns {Function} Returns the new composed function.
+     * @example
+     *
+     * var greet = function(name) { return 'hi ' + name; };
+     * var exclaim = function(statement) { return statement + '!'; };
+     * var welcome = _.compose(exclaim, greet);
+     * welcome('moe');
+     * // => 'hi moe!'
+     */
+    function compose() {
+      var funcs = arguments;
+      return function() {
+        var args = arguments,
+            length = funcs.length;
+
+        while (length--) {
+          args = [funcs[length].apply(this, args)];
+        }
+        return args[0];
+      };
+    }
+
+    /**
+     * Produces a callback bound to an optional `thisArg`. If `func` is a property
+     * name, the created callback will return the property value for a given element.
+     * If `func` is an object, the created callback will return `true` for elements
+     * that contain the equivalent object properties, otherwise it will return `false`.
+     *
+     * Note: All Lo-Dash methods, that accept a `callback` argument, use `_.createCallback`.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Mixed} [func=identity] The value to convert to a callback.
+     * @param {Mixed} [thisArg] The `this` binding of the created callback.
+     * @param {Number} [argCount=3] The number of arguments the callback accepts.
+     * @returns {Function} Returns a callback function.
+     * @example
+     *
+     * var stooges = [
+     *   { 'name': 'moe', 'age': 40 },
+     *   { 'name': 'larry', 'age': 50 }
+     * ];
+     *
+     * // wrap to create custom callback shorthands
+     * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
+     *   var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
+     *   return !match ? func(callback, thisArg) : function(object) {
+     *     return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
+     *   };
+     * });
+     *
+     * _.filter(stooges, 'age__gt45');
+     * // => [{ 'name': 'larry', 'age': 50 }]
+     *
+     * // create mixins with support for "_.pluck" and "_.where" callback shorthands
+     * _.mixin({
+     *   'toLookup': function(collection, callback, thisArg) {
+     *     callback = _.createCallback(callback, thisArg);
+     *     return _.reduce(collection, function(result, value, index, collection) {
+     *       return (result[callback(value, index, collection)] = value, result);
+     *     }, {});
+     *   }
+     * });
+     *
+     * _.toLookup(stooges, 'name');
+     * // => { 'moe': { 'name': 'moe', 'age': 40 }, 'larry': { 'name': 'larry', 'age': 50 } }
+     */
+    function createCallback(func, thisArg, argCount) {
+      if (func == null) {
+        return identity;
+      }
+      var type = typeof func;
+      if (type != 'function') {
+        if (type != 'object') {
+          return function(object) {
+            return object[func];
+          };
+        }
+        var props = keys(func);
+        return function(object) {
+          var length = props.length,
+              result = false;
+          while (length--) {
+            if (!(result = isEqual(object[props[length]], func[props[length]], indicatorObject))) {
+              break;
+            }
+          }
+          return result;
+        };
+      }
+      if (typeof thisArg != 'undefined') {
+        if (argCount === 1) {
+          return function(value) {
+            return func.call(thisArg, value);
+          };
+        }
+        if (argCount === 2) {
+          return function(a, b) {
+            return func.call(thisArg, a, b);
+          };
+        }
+        if (argCount === 4) {
+          return function(accumulator, value, index, collection) {
+            return func.call(thisArg, accumulator, value, index, collection);
+          };
+        }
+        return function(value, index, collection) {
+          return func.call(thisArg, value, index, collection);
+        };
+      }
+      return func;
+    }
+
+    /**
+     * Creates a function that will delay the execution of `func` until after
+     * `wait` milliseconds have elapsed since the last time it was invoked. Pass
+     * an `options` object to indicate that `func` should be invoked on the leading
+     * and/or trailing edge of the `wait` timeout. Subsequent calls to the debounced
+     * function will return the result of the last `func` call.
+     *
+     * Note: If `leading` and `trailing` options are `true`, `func` will be called
+     * on the trailing edge of the timeout only if the the debounced function is
+     * invoked more than once during the `wait` timeout.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to debounce.
+     * @param {Number} wait The number of milliseconds to delay.
+     * @param {Object} options The options object.
+     *  [leading=false] A boolean to specify execution on the leading edge of the timeout.
+     *  [trailing=true] A boolean to specify execution on the trailing edge of the timeout.
+     * @returns {Function} Returns the new debounced function.
+     * @example
+     *
+     * var lazyLayout = _.debounce(calculateLayout, 300);
+     * jQuery(window).on('resize', lazyLayout);
+     *
+     * jQuery('#postbox').on('click', _.debounce(sendMail, 200, {
+     *   'leading': true,
+     *   'trailing': false
+     * });
+     */
+    function debounce(func, wait, options) {
+      var args,
+          inited,
+          result,
+          thisArg,
+          timeoutId,
+          trailing = true;
+
+      function delayed() {
+        inited = timeoutId = null;
+        if (trailing) {
+          result = func.apply(thisArg, args);
+        }
+      }
+      if (options === true) {
+        var leading = true;
+        trailing = false;
+      } else if (options && objectTypes[typeof options]) {
+        leading = options.leading;
+        trailing = 'trailing' in options ? options.trailing : trailing;
+      }
+      return function() {
+        args = arguments;
+        thisArg = this;
+        clearTimeout(timeoutId);
+
+        if (!inited && leading) {
+          inited = true;
+          result = func.apply(thisArg, args);
+        } else {
+          timeoutId = setTimeout(delayed, wait);
+        }
+        return result;
+      };
+    }
+
+    /**
+     * Defers executing the `func` function until the current call stack has cleared.
+     * Additional arguments will be passed to `func` when it is invoked.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to defer.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+     * @returns {Number} Returns the timer id.
+     * @example
+     *
+     * _.defer(function() { alert('deferred'); });
+     * // returns from the function before `alert` is called
+     */
+    function defer(func) {
+      var args = nativeSlice.call(arguments, 1);
+      return setTimeout(function() { func.apply(undefined, args); }, 1);
+    }
+    // use `setImmediate` if it's available in Node.js
+    if (isV8 && freeModule && typeof setImmediate == 'function') {
+      defer = bind(setImmediate, context);
+    }
+
+    /**
+     * Executes the `func` function after `wait` milliseconds. Additional arguments
+     * will be passed to `func` when it is invoked.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to delay.
+     * @param {Number} wait The number of milliseconds to delay execution.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.
+     * @returns {Number} Returns the timer id.
+     * @example
+     *
+     * var log = _.bind(console.log, console);
+     * _.delay(log, 1000, 'logged later');
+     * // => 'logged later' (Appears after one second.)
+     */
+    function delay(func, wait) {
+      var args = nativeSlice.call(arguments, 2);
+      return setTimeout(function() { func.apply(undefined, args); }, wait);
+    }
+
+    /**
+     * Creates a function that memoizes the result of `func`. If `resolver` is
+     * passed, it will be used to determine the cache key for storing the result
+     * based on the arguments passed to the memoized function. By default, the first
+     * argument passed to the memoized function is used as the cache key. The `func`
+     * is executed with the `this` binding of the memoized function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to have its output memoized.
+     * @param {Function} [resolver] A function used to resolve the cache key.
+     * @returns {Function} Returns the new memoizing function.
+     * @example
+     *
+     * var fibonacci = _.memoize(function(n) {
+     *   return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+     * });
+     */
+    function memoize(func, resolver) {
+      var cache = {};
+      return function() {
+        var key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);
+        return hasOwnProperty.call(cache, key)
+          ? cache[key]
+          : (cache[key] = func.apply(this, arguments));
+      };
+    }
+
+    /**
+     * Creates a function that is restricted to execute `func` once. Repeat calls to
+     * the function will return the value of the first call. The `func` is executed
+     * with the `this` binding of the created function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to restrict.
+     * @returns {Function} Returns the new restricted function.
+     * @example
+     *
+     * var initialize = _.once(createApplication);
+     * initialize();
+     * initialize();
+     * // `initialize` executes `createApplication` once
+     */
+    function once(func) {
+      var ran,
+          result;
+
+      return function() {
+        if (ran) {
+          return result;
+        }
+        ran = true;
+        result = func.apply(this, arguments);
+
+        // clear the `func` variable so the function may be garbage collected
+        func = null;
+        return result;
+      };
+    }
+
+    /**
+     * Creates a function that, when called, invokes `func` with any additional
+     * `partial` arguments prepended to those passed to the new function. This
+     * method is similar to `_.bind`, except it does **not** alter the `this` binding.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to partially apply arguments to.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new partially applied function.
+     * @example
+     *
+     * var greet = function(greeting, name) { return greeting + ' ' + name; };
+     * var hi = _.partial(greet, 'hi');
+     * hi('moe');
+     * // => 'hi moe'
+     */
+    function partial(func) {
+      return createBound(func, nativeSlice.call(arguments, 1));
+    }
+
+    /**
+     * This method is similar to `_.partial`, except that `partial` arguments are
+     * appended to those passed to the new function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to partially apply arguments to.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.
+     * @returns {Function} Returns the new partially applied function.
+     * @example
+     *
+     * var defaultsDeep = _.partialRight(_.merge, _.defaults);
+     *
+     * var options = {
+     *   'variable': 'data',
+     *   'imports': { 'jq': $ }
+     * };
+     *
+     * defaultsDeep(options, _.templateSettings);
+     *
+     * options.variable
+     * // => 'data'
+     *
+     * options.imports
+     * // => { '_': _, 'jq': $ }
+     */
+    function partialRight(func) {
+      return createBound(func, nativeSlice.call(arguments, 1), null, indicatorObject);
+    }
+
+    /**
+     * Creates a function that, when executed, will only call the `func` function
+     * at most once per every `wait` milliseconds. Pass an `options` object to
+     * indicate that `func` should be invoked on the leading and/or trailing edge
+     * of the `wait` timeout. Subsequent calls to the throttled function will
+     * return the result of the last `func` call.
+     *
+     * Note: If `leading` and `trailing` options are `true`, `func` will be called
+     * on the trailing edge of the timeout only if the the throttled function is
+     * invoked more than once during the `wait` timeout.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Function} func The function to throttle.
+     * @param {Number} wait The number of milliseconds to throttle executions to.
+     * @param {Object} options The options object.
+     *  [leading=true] A boolean to specify execution on the leading edge of the timeout.
+     *  [trailing=true] A boolean to specify execution on the trailing edge of the timeout.
+     * @returns {Function} Returns the new throttled function.
+     * @example
+     *
+     * var throttled = _.throttle(updatePosition, 100);
+     * jQuery(window).on('scroll', throttled);
+     *
+     * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
+     *   'trailing': false
+     * }));
+     */
+    function throttle(func, wait, options) {
+      var args,
+          result,
+          thisArg,
+          timeoutId,
+          lastCalled = 0,
+          leading = true,
+          trailing = true;
+
+      function trailingCall() {
+        timeoutId = null;
+        if (trailing) {
+          lastCalled = new Date;
+          result = func.apply(thisArg, args);
+        }
+      }
+      if (options === false) {
+        leading = false;
+      } else if (options && objectTypes[typeof options]) {
+        leading = 'leading' in options ? options.leading : leading;
+        trailing = 'trailing' in options ? options.trailing : trailing;
+      }
+      return function() {
+        var now = new Date;
+        if (!timeoutId && !leading) {
+          lastCalled = now;
+        }
+        var remaining = wait - (now - lastCalled);
+        args = arguments;
+        thisArg = this;
+
+        if (remaining <= 0) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+          lastCalled = now;
+          result = func.apply(thisArg, args);
+        }
+        else if (!timeoutId) {
+          timeoutId = setTimeout(trailingCall, remaining);
+        }
+        return result;
+      };
+    }
+
+    /**
+     * Creates a function that passes `value` to the `wrapper` function as its
+     * first argument. Additional arguments passed to the function are appended
+     * to those passed to the `wrapper` function. The `wrapper` is executed with
+     * the `this` binding of the created function.
+     *
+     * @static
+     * @memberOf _
+     * @category Functions
+     * @param {Mixed} value The value to wrap.
+     * @param {Function} wrapper The wrapper function.
+     * @returns {Function} Returns the new function.
+     * @example
+     *
+     * var hello = function(name) { return 'hello ' + name; };
+     * hello = _.wrap(hello, function(func) {
+     *   return 'before, ' + func('moe') + ', after';
+     * });
+     * hello();
+     * // => 'before, hello moe, after'
+     */
+    function wrap(value, wrapper) {
+      return function() {
+        var args = [value];
+        push.apply(args, arguments);
+        return wrapper.apply(this, args);
+      };
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+     * corresponding HTML entities.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} string The string to escape.
+     * @returns {String} Returns the escaped string.
+     * @example
+     *
+     * _.escape('Moe, Larry & Curly');
+     * // => 'Moe, Larry &amp; Curly'
+     */
+    function escape(string) {
+      return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
+    }
+
+    /**
+     * This function returns the first argument passed to it.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Mixed} value Any value.
+     * @returns {Mixed} Returns `value`.
+     * @example
+     *
+     * var moe = { 'name': 'moe' };
+     * moe === _.identity(moe);
+     * // => true
+     */
+    function identity(value) {
+      return value;
+    }
+
+    /**
+     * Adds functions properties of `object` to the `lodash` function and chainable
+     * wrapper.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Object} object The object of function properties to add to `lodash`.
+     * @example
+     *
+     * _.mixin({
+     *   'capitalize': function(string) {
+     *     return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+     *   }
+     * });
+     *
+     * _.capitalize('moe');
+     * // => 'Moe'
+     *
+     * _('moe').capitalize();
+     * // => 'Moe'
+     */
+    function mixin(object) {
+      forEach(functions(object), function(methodName) {
+        var func = lodash[methodName] = object[methodName];
+
+        lodash.prototype[methodName] = function() {
+          var value = this.__wrapped__,
+              args = [value];
+
+          push.apply(args, arguments);
+          var result = func.apply(lodash, args);
+          return (value && typeof value == 'object' && value == result)
+            ? this
+            : new lodashWrapper(result);
+        };
+      });
+    }
+
+    /**
+     * Reverts the '_' variable to its previous value and returns a reference to
+     * the `lodash` function.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @returns {Function} Returns the `lodash` function.
+     * @example
+     *
+     * var lodash = _.noConflict();
+     */
+    function noConflict() {
+      context._ = oldDash;
+      return this;
+    }
+
+    /**
+     * Converts the given `value` into an integer of the specified `radix`.
+     * If `radix` is `undefined` or `0`, a `radix` of `10` is used unless the
+     * `value` is a hexadecimal, in which case a `radix` of `16` is used.
+     *
+     * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+     * implementations. See http://es5.github.com/#E.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} value The value to parse.
+     * @param {Number} [radix] The radix used to interpret the value to parse.
+     * @returns {Number} Returns the new integer value.
+     * @example
+     *
+     * _.parseInt('08');
+     * // => 8
+     */
+    var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
+      // Firefox and Opera still follow the ES3 specified implementation of `parseInt`
+      return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
+    };
+
+    /**
+     * Produces a random number between `min` and `max` (inclusive). If only one
+     * argument is passed, a number between `0` and the given number will be returned.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Number} [min=0] The minimum possible value.
+     * @param {Number} [max=1] The maximum possible value.
+     * @returns {Number} Returns a random number.
+     * @example
+     *
+     * _.random(0, 5);
+     * // => a number between 0 and 5
+     *
+     * _.random(5);
+     * // => also a number between 0 and 5
+     */
+    function random(min, max) {
+      if (min == null && max == null) {
+        max = 1;
+      }
+      min = +min || 0;
+      if (max == null) {
+        max = min;
+        min = 0;
+      }
+      return min + floor(nativeRandom() * ((+max || 0) - min + 1));
+    }
+
+    /**
+     * Resolves the value of `property` on `object`. If `property` is a function,
+     * it will be invoked with the `this` binding of `object` and its result returned,
+     * else the property value is returned. If `object` is falsey, then `undefined`
+     * is returned.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Object} object The object to inspect.
+     * @param {String} property The property to get the value of.
+     * @returns {Mixed} Returns the resolved value.
+     * @example
+     *
+     * var object = {
+     *   'cheese': 'crumpets',
+     *   'stuff': function() {
+     *     return 'nonsense';
+     *   }
+     * };
+     *
+     * _.result(object, 'cheese');
+     * // => 'crumpets'
+     *
+     * _.result(object, 'stuff');
+     * // => 'nonsense'
+     */
+    function result(object, property) {
+      var value = object ? object[property] : undefined;
+      return isFunction(value) ? object[property]() : value;
+    }
+
+    /**
+     * A micro-templating method that handles arbitrary delimiters, preserves
+     * whitespace, and correctly escapes quotes within interpolated code.
+     *
+     * Note: In the development build, `_.template` utilizes sourceURLs for easier
+     * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+     *
+     * For more information on precompiling templates see:
+     * http://lodash.com/#custom-builds
+     *
+     * For more information on Chrome extension sandboxes see:
+     * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} text The template text.
+     * @param {Object} data The data object used to populate the text.
+     * @param {Object} options The options object.
+     *  escape - The "escape" delimiter regexp.
+     *  evaluate - The "evaluate" delimiter regexp.
+     *  interpolate - The "interpolate" delimiter regexp.
+     *  sourceURL - The sourceURL of the template's compiled source.
+     *  variable - The data object variable name.
+     * @returns {Function|String} Returns a compiled function when no `data` object
+     *  is given, else it returns the interpolated text.
+     * @example
+     *
+     * // using a compiled template
+     * var compiled = _.template('hello <%= name %>');
+     * compiled({ 'name': 'moe' });
+     * // => 'hello moe'
+     *
+     * var list = '<% _.forEach(people, function(name) { %><li><%= name %></li><% }); %>';
+     * _.template(list, { 'people': ['moe', 'larry'] });
+     * // => '<li>moe</li><li>larry</li>'
+     *
+     * // using the "escape" delimiter to escape HTML in data property values
+     * _.template('<b><%- value %></b>', { 'value': '<script>' });
+     * // => '<b>&lt;script&gt;</b>'
+     *
+     * // using the ES6 delimiter as an alternative to the default "interpolate" delimiter
+     * _.template('hello ${ name }', { 'name': 'curly' });
+     * // => 'hello curly'
+     *
+     * // using the internal `print` function in "evaluate" delimiters
+     * _.template('<% print("hello " + epithet); %>!', { 'epithet': 'stooge' });
+     * // => 'hello stooge!'
+     *
+     * // using custom template delimiters
+     * _.templateSettings = {
+     *   'interpolate': /{{([\s\S]+?)}}/g
+     * };
+     *
+     * _.template('hello {{ name }}!', { 'name': 'mustache' });
+     * // => 'hello mustache!'
+     *
+     * // using the `sourceURL` option to specify a custom sourceURL for the template
+     * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });
+     * compiled(data);
+     * // => find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector
+     *
+     * // using the `variable` option to ensure a with-statement isn't used in the compiled template
+     * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });
+     * compiled.source;
+     * // => function(data) {
+     *   var __t, __p = '', __e = _.escape;
+     *   __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';
+     *   return __p;
+     * }
+     *
+     * // using the `source` property to inline compiled templates for meaningful
+     * // line numbers in error messages and a stack trace
+     * fs.writeFileSync(path.join(cwd, 'jst.js'), '\
+     *   var JST = {\
+     *     "main": ' + _.template(mainText).source + '\
+     *   };\
+     * ');
+     */
+    function template(text, data, options) {
+      // based on John Resig's `tmpl` implementation
+      // http://ejohn.org/blog/javascript-micro-templating/
+      // and Laura Doktorova's doT.js
+      // https://github.com/olado/doT
+      var settings = lodash.templateSettings;
+      text || (text = '');
+
+      // avoid missing dependencies when `iteratorTemplate` is not defined
+      options = defaults({}, options, settings);
+
+      var imports = defaults({}, options.imports, settings.imports),
+          importsKeys = keys(imports),
+          importsValues = values(imports);
+
+      var isEvaluating,
+          index = 0,
+          interpolate = options.interpolate || reNoMatch,
+          source = "__p += '";
+
+      // compile the regexp to match each delimiter
+      var reDelimiters = RegExp(
+        (options.escape || reNoMatch).source + '|' +
+        interpolate.source + '|' +
+        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
+        (options.evaluate || reNoMatch).source + '|$'
+      , 'g');
+
+      text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
+        interpolateValue || (interpolateValue = esTemplateValue);
+
+        // escape characters that cannot be included in string literals
+        source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);
+
+        // replace delimiters with snippets
+        if (escapeValue) {
+          source += "' +\n__e(" + escapeValue + ") +\n'";
+        }
+        if (evaluateValue) {
+          isEvaluating = true;
+          source += "';\n" + evaluateValue + ";\n__p += '";
+        }
+        if (interpolateValue) {
+          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
+        }
+        index = offset + match.length;
+
+        // the JS engine embedded in Adobe products requires returning the `match`
+        // string in order to produce the correct `offset` value
+        return match;
+      });
+
+      source += "';\n";
+
+      // if `variable` is not specified, wrap a with-statement around the generated
+      // code to add the data object to the top of the scope chain
+      var variable = options.variable,
+          hasVariable = variable;
+
+      if (!hasVariable) {
+        variable = 'obj';
+        source = 'with (' + variable + ') {\n' + source + '\n}\n';
+      }
+      // cleanup code by stripping empty strings
+      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
+        .replace(reEmptyStringMiddle, '$1')
+        .replace(reEmptyStringTrailing, '$1;');
+
+      // frame code as the function body
+      source = 'function(' + variable + ') {\n' +
+        (hasVariable ? '' : variable + ' || (' + variable + ' = {});\n') +
+        "var __t, __p = '', __e = _.escape" +
+        (isEvaluating
+          ? ', __j = Array.prototype.join;\n' +
+            "function print() { __p += __j.call(arguments, '') }\n"
+          : ';\n'
+        ) +
+        source +
+        'return __p\n}';
+
+      // Use a sourceURL for easier debugging and wrap in a multi-line comment to
+      // avoid issues with Narwhal, IE conditional compilation, and the JS engine
+      // embedded in Adobe products.
+      // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+      var sourceURL = '\n/*\n//@ sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\n*/';
+
+      try {
+        var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);
+      } catch(e) {
+        e.source = source;
+        throw e;
+      }
+      if (data) {
+        return result(data);
+      }
+      // provide the compiled function's source via its `toString` method, in
+      // supported environments, or the `source` property as a convenience for
+      // inlining compiled templates during the build process
+      result.source = source;
+      return result;
+    }
+
+    /**
+     * Executes the `callback` function `n` times, returning an array of the results
+     * of each `callback` execution. The `callback` is bound to `thisArg` and invoked
+     * with one argument; (index).
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {Number} n The number of times to execute the callback.
+     * @param {Function} callback The function called per iteration.
+     * @param {Mixed} [thisArg] The `this` binding of `callback`.
+     * @returns {Array} Returns a new array of the results of each `callback` execution.
+     * @example
+     *
+     * var diceRolls = _.times(3, _.partial(_.random, 1, 6));
+     * // => [3, 6, 4]
+     *
+     * _.times(3, function(n) { mage.castSpell(n); });
+     * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively
+     *
+     * _.times(3, function(n) { this.cast(n); }, mage);
+     * // => also calls `mage.castSpell(n)` three times
+     */
+    function times(n, callback, thisArg) {
+      n = (n = +n) > -1 ? n : 0;
+      var index = -1,
+          result = Array(n);
+
+      callback = lodash.createCallback(callback, thisArg, 1);
+      while (++index < n) {
+        result[index] = callback(index);
+      }
+      return result;
+    }
+
+    /**
+     * The inverse of `_.escape`, this method converts the HTML entities
+     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to their
+     * corresponding characters.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} string The string to unescape.
+     * @returns {String} Returns the unescaped string.
+     * @example
+     *
+     * _.unescape('Moe, Larry &amp; Curly');
+     * // => 'Moe, Larry & Curly'
+     */
+    function unescape(string) {
+      return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);
+    }
+
+    /**
+     * Generates a unique ID. If `prefix` is passed, the ID will be appended to it.
+     *
+     * @static
+     * @memberOf _
+     * @category Utilities
+     * @param {String} [prefix] The value to prefix the ID with.
+     * @returns {String} Returns the unique ID.
+     * @example
+     *
+     * _.uniqueId('contact_');
+     * // => 'contact_104'
+     *
+     * _.uniqueId();
+     * // => '105'
+     */
+    function uniqueId(prefix) {
+      var id = ++idCounter;
+      return String(prefix == null ? '' : prefix) + id;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * Invokes `interceptor` with the `value` as the first argument, and then
+     * returns `value`. The purpose of this method is to "tap into" a method chain,
+     * in order to perform operations on intermediate results within the chain.
+     *
+     * @static
+     * @memberOf _
+     * @category Chaining
+     * @param {Mixed} value The value to pass to `interceptor`.
+     * @param {Function} interceptor The function to invoke.
+     * @returns {Mixed} Returns `value`.
+     * @example
+     *
+     * _([1, 2, 3, 4])
+     *  .filter(function(num) { return num % 2 == 0; })
+     *  .tap(alert)
+     *  .map(function(num) { return num * num; })
+     *  .value();
+     * // => // [2, 4] (alerted)
+     * // => [4, 16]
+     */
+    function tap(value, interceptor) {
+      interceptor(value);
+      return value;
+    }
+
+    /**
+     * Produces the `toString` result of the wrapped value.
+     *
+     * @name toString
+     * @memberOf _
+     * @category Chaining
+     * @returns {String} Returns the string result.
+     * @example
+     *
+     * _([1, 2, 3]).toString();
+     * // => '1,2,3'
+     */
+    function wrapperToString() {
+      return String(this.__wrapped__);
+    }
+
+    /**
+     * Extracts the wrapped value.
+     *
+     * @name valueOf
+     * @memberOf _
+     * @alias value
+     * @category Chaining
+     * @returns {Mixed} Returns the wrapped value.
+     * @example
+     *
+     * _([1, 2, 3]).valueOf();
+     * // => [1, 2, 3]
+     */
+    function wrapperValueOf() {
+      return this.__wrapped__;
+    }
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions that return wrapped values when chaining
+    lodash.after = after;
+    lodash.assign = assign;
+    lodash.at = at;
+    lodash.bind = bind;
+    lodash.bindAll = bindAll;
+    lodash.bindKey = bindKey;
+    lodash.compact = compact;
+    lodash.compose = compose;
+    lodash.countBy = countBy;
+    lodash.createCallback = createCallback;
+    lodash.debounce = debounce;
+    lodash.defaults = defaults;
+    lodash.defer = defer;
+    lodash.delay = delay;
+    lodash.difference = difference;
+    lodash.filter = filter;
+    lodash.flatten = flatten;
+    lodash.forEach = forEach;
+    lodash.forIn = forIn;
+    lodash.forOwn = forOwn;
+    lodash.functions = functions;
+    lodash.groupBy = groupBy;
+    lodash.initial = initial;
+    lodash.intersection = intersection;
+    lodash.invert = invert;
+    lodash.invoke = invoke;
+    lodash.keys = keys;
+    lodash.map = map;
+    lodash.max = max;
+    lodash.memoize = memoize;
+    lodash.merge = merge;
+    lodash.min = min;
+    lodash.omit = omit;
+    lodash.once = once;
+    lodash.pairs = pairs;
+    lodash.partial = partial;
+    lodash.partialRight = partialRight;
+    lodash.pick = pick;
+    lodash.pluck = pluck;
+    lodash.range = range;
+    lodash.reject = reject;
+    lodash.rest = rest;
+    lodash.shuffle = shuffle;
+    lodash.sortBy = sortBy;
+    lodash.tap = tap;
+    lodash.throttle = throttle;
+    lodash.times = times;
+    lodash.toArray = toArray;
+    lodash.union = union;
+    lodash.uniq = uniq;
+    lodash.unzip = unzip;
+    lodash.values = values;
+    lodash.where = where;
+    lodash.without = without;
+    lodash.wrap = wrap;
+    lodash.zip = zip;
+    lodash.zipObject = zipObject;
+
+    // add aliases
+    lodash.collect = map;
+    lodash.drop = rest;
+    lodash.each = forEach;
+    lodash.extend = assign;
+    lodash.methods = functions;
+    lodash.object = zipObject;
+    lodash.select = filter;
+    lodash.tail = rest;
+    lodash.unique = uniq;
+
+    // add functions to `lodash.prototype`
+    mixin(lodash);
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions that return unwrapped values when chaining
+    lodash.clone = clone;
+    lodash.cloneDeep = cloneDeep;
+    lodash.contains = contains;
+    lodash.escape = escape;
+    lodash.every = every;
+    lodash.find = find;
+    lodash.findIndex = findIndex;
+    lodash.findKey = findKey;
+    lodash.has = has;
+    lodash.identity = identity;
+    lodash.indexOf = indexOf;
+    lodash.isArguments = isArguments;
+    lodash.isArray = isArray;
+    lodash.isBoolean = isBoolean;
+    lodash.isDate = isDate;
+    lodash.isElement = isElement;
+    lodash.isEmpty = isEmpty;
+    lodash.isEqual = isEqual;
+    lodash.isFinite = isFinite;
+    lodash.isFunction = isFunction;
+    lodash.isNaN = isNaN;
+    lodash.isNull = isNull;
+    lodash.isNumber = isNumber;
+    lodash.isObject = isObject;
+    lodash.isPlainObject = isPlainObject;
+    lodash.isRegExp = isRegExp;
+    lodash.isString = isString;
+    lodash.isUndefined = isUndefined;
+    lodash.lastIndexOf = lastIndexOf;
+    lodash.mixin = mixin;
+    lodash.noConflict = noConflict;
+    lodash.parseInt = parseInt;
+    lodash.random = random;
+    lodash.reduce = reduce;
+    lodash.reduceRight = reduceRight;
+    lodash.result = result;
+    lodash.runInContext = runInContext;
+    lodash.size = size;
+    lodash.some = some;
+    lodash.sortedIndex = sortedIndex;
+    lodash.template = template;
+    lodash.unescape = unescape;
+    lodash.uniqueId = uniqueId;
+
+    // add aliases
+    lodash.all = every;
+    lodash.any = some;
+    lodash.detect = find;
+    lodash.foldl = reduce;
+    lodash.foldr = reduceRight;
+    lodash.include = contains;
+    lodash.inject = reduce;
+
+    forOwn(lodash, function(func, methodName) {
+      if (!lodash.prototype[methodName]) {
+        lodash.prototype[methodName] = function() {
+          var args = [this.__wrapped__];
+          push.apply(args, arguments);
+          return func.apply(lodash, args);
+        };
+      }
+    });
+
+    /*--------------------------------------------------------------------------*/
+
+    // add functions capable of returning wrapped and unwrapped values when chaining
+    lodash.first = first;
+    lodash.last = last;
+
+    // add aliases
+    lodash.take = first;
+    lodash.head = first;
+
+    forOwn(lodash, function(func, methodName) {
+      if (!lodash.prototype[methodName]) {
+        lodash.prototype[methodName]= function(callback, thisArg) {
+          var result = func(this.__wrapped__, callback, thisArg);
+          return callback == null || (thisArg && typeof callback != 'function')
+            ? result
+            : new lodashWrapper(result);
+        };
+      }
+    });
+
+    /*--------------------------------------------------------------------------*/
+
+    /**
+     * The semantic version number.
+     *
+     * @static
+     * @memberOf _
+     * @type String
+     */
+    lodash.VERSION = '1.2.1';
+
+    // add "Chaining" functions to the wrapper
+    lodash.prototype.toString = wrapperToString;
+    lodash.prototype.value = wrapperValueOf;
+    lodash.prototype.valueOf = wrapperValueOf;
+
+    // add `Array` functions that return unwrapped values
+    forEach(['join', 'pop', 'shift'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        return func.apply(this.__wrapped__, arguments);
+      };
+    });
+
+    // add `Array` functions that return the wrapped value
+    forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        func.apply(this.__wrapped__, arguments);
+        return this;
+      };
+    });
+
+    // add `Array` functions that return new wrapped values
+    forEach(['concat', 'slice', 'splice'], function(methodName) {
+      var func = arrayRef[methodName];
+      lodash.prototype[methodName] = function() {
+        return new lodashWrapper(func.apply(this.__wrapped__, arguments));
+      };
+    });
+
+    return lodash;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  // expose Lo-Dash
+  var _ = runInContext();
+
+  // some AMD build optimizers, like r.js, check for specific condition patterns like the following:
+  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
+    // Expose Lo-Dash to the global object even when an AMD loader is present in
+    // case Lo-Dash was injected by a third-party script and not intended to be
+    // loaded as a module. The global assignment can be reverted in the Lo-Dash
+    // module via its `noConflict()` method.
+    window._ = _;
+
+    // define as an anonymous module so, through path mapping, it can be
+    // referenced as the "underscore" module
+    define(function() {
+      return _;
+    });
+  }
+  // check for `exports` after `define` in case a build optimizer adds an `exports` object
+  else if (freeExports && !freeExports.nodeType) {
+    // in Node.js or RingoJS v0.8.0+
+    if (freeModule) {
+      (freeModule.exports = _)._ = _;
+    }
+    // in Narwhal or RingoJS v0.7.0-
+    else {
+      freeExports._ = _;
+    }
+  }
+  else {
+    // in a browser or Rhino
+    window._ = _;
+  }
+}(this));
+
+})(window)
+},{}],8:[function(require,module,exports){
+var relativeDate = (function(undefined){
+
+  var SECOND = 1000,
+      MINUTE = 60 * SECOND,
+      HOUR = 60 * MINUTE,
+      DAY = 24 * HOUR,
+      WEEK = 7 * DAY,
+      YEAR = DAY * 365,
+      MONTH = YEAR / 12;
+
+  var formats = [
+    [ 0.7 * MINUTE, 'just now' ],
+    [ 1.5 * MINUTE, 'a minute ago' ],
+    [ 60 * MINUTE, 'minutes ago', MINUTE ],
+    [ 1.5 * HOUR, 'an hour ago' ],
+    [ DAY, 'hours ago', HOUR ],
+    [ 2 * DAY, 'yesterday' ],
+    [ 7 * DAY, 'days ago', DAY ],
+    [ 1.5 * WEEK, 'a week ago'],
+    [ MONTH, 'weeks ago', WEEK ],
+    [ 1.5 * MONTH, 'a month ago' ],
+    [ YEAR, 'months ago', MONTH ],
+    [ 1.5 * YEAR, 'a year ago' ],
+    [ Number.MAX_VALUE, 'years ago', YEAR ]
+  ];
+
+  function relativeDate(input,reference){
+    !reference && ( reference = (new Date).getTime() );
+    reference instanceof Date && ( reference = reference.getTime() );
+    input instanceof Date && ( input = input.getTime() );
+    
+    var delta = reference - input,
+        format, i, len;
+
+    for(i = -1, len=formats.length; ++i < len; ){
+      format = formats[i];
+      if(delta < format[0]){
+        return format[2] == undefined ? format[1] : Math.round(delta/format[2]) + ' ' + format[1];
+      }
+    };
+  }
+
+  return relativeDate;
+
+})();
+
+if(typeof module != 'undefined' && module.exports){
+  module.exports = relativeDate;
+}
+
+},{}]},{},[1])
+//@ sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["/Users/y/github/odesk/habitrpg-shared/script/index.js","/Users/y/github/odesk/habitrpg-shared/script/algos.coffee","/Users/y/github/odesk/habitrpg-shared/script/items.coffee","/Users/y/github/odesk/habitrpg-shared/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js","/Users/y/github/odesk/habitrpg-shared/script/helpers.coffee","/Users/y/github/odesk/habitrpg-shared/node_modules/moment/moment.js","/Users/y/github/odesk/habitrpg-shared/node_modules/lodash/dist/lodash.js","/Users/y/github/odesk/habitrpg-shared/node_modules/relative-date/lib/relative-date.js"],"names":[],"mappings":"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A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACz3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjpKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["exports.algos = require('./algos.coffee');\nexports.items = require('./items.coffee');\nexports.helpers = require('./helpers.coffee');\n\ntry {\n    window;\n    window.habitrpgShared = exports;\n} catch(e) {}","moment = require('moment')\n_ = require('lodash')\n\nhelpers = require('./helpers.coffee')\nitems = require('./items.coffee')\n{pets, hatchingPotions} = items.items\n\nXP = 15\nHP = 2\nobj = module.exports = {}\n\n\nobj.priorityValue = (priority = '!') ->\n  switch priority\n    when '!' then 1\n    when '!!' then 1.5\n    when '!!!' then 2\n    else 1\n\nobj.tnl = (level) ->\n  if level >= 100\n    value = 0\n  else\n    value = Math.round(((Math.pow(level, 2) * 0.25) + (10 * level) + 139.75) / 10) * 10\n  # round to nearest 10\n  return value\n\n###\n  Calculates Exp modificaiton based on level and weapon strength\n  {value} task.value for exp gain\n  {weaponStrength) weapon strength\n  {level} current user level\n  {priority} user-defined priority multiplier\n###\nobj.expModifier = (value, weaponStr, level, priority = '!') ->\n  str = (level - 1) / 2\n  # ultimately get this from user\n  totalStr = (str + weaponStr) / 100\n  strMod = 1 + totalStr\n  exp = value * XP * strMod * obj.priorityValue(priority)\n  return Math.round(exp)\n\n###\n  Calculates HP modification based on level and armor defence\n  {value} task.value for hp loss\n  {armorDefense} defense from armor\n  {helmDefense} defense from helm\n  {level} current user level\n  {priority} user-defined priority multiplier\n###\nobj.hpModifier = (value, armorDef, helmDef, shieldDef, level, priority = '!') ->\n  def = (level - 1) / 2\n  # ultimately get this from user?\n  totalDef = (def + armorDef + helmDef + shieldDef) / 100\n  #ultimate get this from user\n  defMod = 1 - totalDef\n  hp = value * HP * defMod * obj.priorityValue(priority)\n  return Math.round(hp * 10) / 10\n# round to 1dp\n\n###\n  Future use\n  {priority} user-defined priority multiplier\n###\nobj.gpModifier = (value, modifier, priority = '!', streak, user) ->\n  val = value * modifier * obj.priorityValue(priority)\n  if streak and user\n    streakBonus = streak / 100 + 1 # eg, 1-day streak is 1.1, 2-day is 1.2, etc\n    afterStreak = val * streakBonus\n    (user._tmp?={}).streakBonus = afterStreak - val if (val > 0) # keep this on-hand for later, so we can notify streak-bonus\n    return afterStreak\n  else\n    return val\n\n###\n  Calculates the next task.value based on direction\n  Uses a capped inverse log y=.95^x, y>= -5\n  {currentValue} the current value of the task\n  {direction} up or down\n###\nobj.taskDeltaFormula = (currentValue, direction) ->\n  if currentValue < -47.27 then currentValue = -47.27\n  else if currentValue > 21.27 then currentValue = 21.27\n  delta = Math.pow(0.9747, currentValue)\n  return delta if direction is 'up'\n  return -delta\n\n\n###\n  Drop System\n###\n\nrandomDrop = (user, delta, priority, streak = 0, paths) ->\n  # limit drops to 2 / day\n  user.items.lastDrop ?=\n    date: +moment().subtract('d', 1) # trick - set it to yesterday on first run, that way they can get drops today\n    count: 0\n  paths['items.lastDrop'] = true\n  reachedDropLimit = (helpers.daysBetween(user.items.lastDrop.date, +new Date) is 0) and (user.items.lastDrop.count >= 2)\n  return if reachedDropLimit\n\n  # % chance of getting a pet or meat\n  chanceMultiplier = Math.abs(delta)\n  chanceMultiplier *= obj.priorityValue(priority) # multiply chance by reddness\n  chanceMultiplier += streak # streak bonus\n\n  if user.flags?.dropsEnabled and Math.random() < (.05 * chanceMultiplier)\n    # current breakdown - 1% (adjustable) chance on drop\n    # If they got a drop: 50% chance of egg, 50% Hatching Potion. If hatchingPotion, broken down further even further\n    rarity = Math.random()\n\n    # Egg, 40% chance\n    if rarity > .6\n      drop = helpers.randomVal(pets)\n      (user.items.eggs ?= []).push drop; paths['items.eggs'] = true\n      drop.type = 'Egg'\n      drop.dialog = \"You've found a #{drop.text} Egg! #{drop.notes}\"\n\n      # Hatching Potion, 60% chance - break down by rarity even more. FIXME this may not be the best method, so revisit\n    else\n      acceptableDrops = []\n\n      # Tier 5 (Blue Moon Rare)\n      if rarity < .1\n        acceptableDrops =\n          ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton', 'Zombie', 'CottonCandyPink', 'CottonCandyBlue',\n           'Golden']\n\n        # Tier 4 (Very Rare)\n      else if rarity < .2\n        acceptableDrops =\n          ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton', 'Zombie', 'CottonCandyPink', 'CottonCandyBlue']\n\n        # Tier 3 (Rare)\n      else if rarity < .3\n        acceptableDrops = ['Base', 'White', 'Desert', 'Red', 'Shade', 'Skeleton']\n\n        # Tier 2 (Scarce)\n      else if rarity < .4\n        acceptableDrops = ['Base', 'White', 'Desert']\n        # Tier 1 (Common)\n      else\n        acceptableDrops = ['Base']\n\n      acceptableDrops = hatchingPotions.filter (hatchingPotion) ->\n        hatchingPotion.name in acceptableDrops\n      drop = helpers.randomVal acceptableDrops\n      (user.items.hatchingPotions ?= []).push drop.name; paths['items.hatchingPotions'] = true\n      drop.type = 'HatchingPotion'\n      drop.dialog = \"You've found a #{drop.text} Hatching Potion! #{drop.notes}\"\n\n    # if they've dropped something, we want the consuming client to know so they can notify the user. See how the Derby\n    # app handles it for example. Would this be better handled as an emit() ?\n    (user._tmp?={}).drop = drop\n\n    user.items.lastDrop.date = +new Date\n    user.items.lastDrop.count++\n    paths['items.lastDrop'] = true\n\n#  {task} task you want to score\n#  {direction} 'up' or 'down'\nobj.score = (user, task, direction, options={}) ->\n  {gp, hp, exp, lvl} = user.stats\n  {type, value, streak} = task\n  [paths, times, cron] = [options.paths || {}, options.times || 1, options.cron || false]\n  priority = task.priority or '!'\n\n  # If they're trying to purhcase a too-expensive reward, confirm they want to take a hit for it\n  if task.value > user.stats.gp and task.type is 'reward'\n    return unless confirm \"Not enough GP to purchase this reward, buy anyway and lose HP? (Punishment for taking a reward you didn't earn).\"\n\n  delta = 0\n  calculateDelta = (adjustvalue = true) ->\n    # If multiple days have passed, multiply times days missed\n    _.times times, ->\n      # Each iteration calculate the delta (nextDelta), which is then accumulated in delta\n      # (aka, the total delta). This weirdness won't be necessary when calculating mathematically\n      # rather than iteratively\n      nextDelta = obj.taskDeltaFormula(value, direction)\n      value += nextDelta if adjustvalue\n      delta += nextDelta\n\n  addPoints = ->\n    level = user.stats.lvl\n    weaponStrength = items.items.weapon[user.items.weapon].strength\n    exp += obj.expModifier(delta, weaponStrength, level, priority) / 2\n    # / 2 hack for now bcause people leveling too fast\n    if streak\n      gp += obj.gpModifier(delta, 1, priority, streak, user)\n    else\n      gp += obj.gpModifier(delta, 1, priority)\n\n\n  subtractPoints = ->\n    level = user.stats.lvl\n    armorDefense = items.items.armor[user.items.armor].defense\n    helmDefense = items.items.head[user.items.head].defense\n    shieldDefense = items.items.shield[user.items.shield].defense\n    hp += obj.hpModifier(delta, armorDefense, helmDefense, shieldDefense, level, priority)\n\n  switch type\n    when 'habit'\n      calculateDelta()\n      # Add habit value to habit-history (if different)\n      if (delta > 0) then addPoints() else subtractPoints()\n      if task.value != value\n        (task.history ?= []).push { date: +new Date, value: value }; paths[\"tasks.#{task.id}.history\"] = true\n\n    when 'daily'\n      if cron\n        calculateDelta()\n        subtractPoints()\n        task.streak = 0\n      else\n        calculateDelta(false)\n        if delta != 0\n          addPoints() # obviously for delta>0, but also a trick to undo accidental checkboxes\n          if direction is 'up'\n            streak = if streak then streak + 1 else 1\n          else\n            streak = if streak then streak - 1 else 0\n          task.streak = streak\n      paths[\"tasks.#{task.id}.streak\"] = true\n\n    when 'todo'\n      if cron\n        calculateDelta()\n        #don't touch stats on cron\n      else\n        calculateDelta()\n        addPoints() # obviously for delta>0, but also a trick to undo accidental checkboxes\n\n    when 'reward'\n    # Don't adjust values for rewards\n      calculateDelta(false)\n      # purchase item\n      gp -= Math.abs(task.value)\n      num = parseFloat(task.value).toFixed(2)\n      # if too expensive, reduce health & zero gp\n      if gp < 0\n        hp += gp\n        # hp - gp difference\n        gp = 0\n\n  task.value = value; paths[\"tasks.#{task.id}.value\"] = true\n  updateStats user, { hp, exp, gp }, paths\n\n  # Drop system #FIXME\n  randomDrop(user, delta, priority, streak, paths) if direction is 'up'\n\n  return delta\n\n###\n  Updates user stats with new stats. Handles death, leveling up, etc\n  {stats} new stats\n  {update} if aggregated changes, pass in userObj as update. otherwise commits will be made immediately\n###\nupdateStats = (user, newStats, paths) ->\n  # if user is dead, dont do anything\n  return if user.stats.hp <= 0\n\n  if newStats.hp?\n    # Game Over\n    if newStats.hp <= 0\n      user.stats.hp = 0 # signifies dead\n      return\n    else\n      user.stats.hp = newStats.hp\n    paths['stats.hp'] = true\n\n  if newStats.exp?\n    tnl = obj.tnl(user.stats.lvl)\n    #silent = false\n    # if we're at level 100, turn xp to gold\n    if user.stats.lvl >= 100\n      newStats.gp += newStats.exp / 15\n      newStats.exp = 0\n      user.stats.lvl = 100\n    else\n      # level up & carry-over exp\n      if newStats.exp >= tnl\n        #silent = true # push through the negative xp silently\n        user.stats.exp = newStats.exp # push normal + notification\n        while newStats.exp >= tnl and user.stats.lvl < 100 # keep levelling up\n          newStats.exp -= tnl\n          user.stats.lvl++\n          tnl = obj.tnl(user.stats.lvl)\n        if user.stats.lvl == 100\n          newStats.exp = 0\n        user.stats.hp = 50\n\n    user.stats.exp = newStats.exp\n\n    paths[\"stats.exp\"]=true; paths['stats.lvl']=true; paths['stats.gp']=true; paths['stats.hp']=true;\n    #if silent\n    #console.log(\"pushing silent :\"  + obj.stats.exp)\n\n\n    # Set flags when they unlock features\n    user.flags ?= {}\n    if !user.flags.customizationsNotification and (user.stats.exp > 10 or user.stats.lvl > 1)\n      user.flags.customizationsNotification = true; paths['flags.customizationsNotification']=true;\n    if !user.flags.itemsEnabled and user.stats.lvl >= 2\n      user.flags.itemsEnabled = true; paths['flags.itemsEnabled']=true;\n    if !user.flags.partyEnabled and user.stats.lvl >= 3\n      user.flags.partyEnabled = true; paths['flags.partyEnabled']=true;\n    if !user.flags.dropsEnabled and user.stats.lvl >= 4\n      user.flags.dropsEnabled = true; paths['flags.dropsEnabled']=true;\n\n  if newStats.gp?\n    #FIXME what was I doing here? I can't remember, gp isn't defined\n    gp = 0.0 if (!gp? or gp < 0)\n    user.stats.gp = newStats.gp\n\nobj.shouldCron = (user) ->\n  true if !user.lastCron? or user.lastCron is 'new' or helpers.daysBetween(user.lastCron, +new Date, user.preferences?.dayStart) > 0\n\n###\n  At end of day, add value to all incomplete Daily & Todo tasks (further incentive)\n  For incomplete Dailys, deduct experience\n  Make sure to run this function once in a while as server will not take care of overnight calculations.\n  And you have to run it every time client connects.\n###\nobj.cron = (user, paths={}) ->\n  today = +new Date\n\n  lastCron = user.lastCron\n  # New user (!lastCron, lastCron==new) or it got busted somehow, maybe they went to a different timezone\n  if !lastCron? or lastCron is 'new' or moment(lastCron).isAfter(today)\n    user.lastCron = today; paths['lastCron'] = true\n    return\n\n  daysMissed = helpers.daysBetween(user.lastCron, today, user.preferences?.dayStart)\n  if daysMissed > 0\n    user.lastCron = today; paths['lastCron'] = true\n\n    # User is resting at the inn. Used to be we un-checked each daily without performing calculation (see commits before fb29e35)\n    # but to prevent abusing the inn (http://goo.gl/GDb9x) we now do *not* calculate dailies, and simply set lastCron to today\n    return if user.flags.rest is true\n\n    # Tally each task\n    todoTally = 0\n    user.todos.concat(user.dailys).forEach (task) ->\n      {id, type, completed, repeat} = task\n      # Deduct experience for missed Daily tasks, but not for Todos (just increase todo's value)\n      unless completed\n        scheduleMisses = daysMissed\n        # for dailys which have repeat dates, need to calculate how many they've missed according to their own schedule\n        if (type is 'daily') and repeat\n          scheduleMisses = 0\n          _.times daysMissed, (n) ->\n            thatDay = moment(today).subtract('days', n + 1)\n            scheduleMisses++ if helpers.shouldDo(thatDay, repeat, obj.preferences?.dayStart) is true\n        obj.score(user, task, 'down', {times:scheduleMisses, cron:true, paths:paths}) if scheduleMisses > 0\n\n      switch type\n        when 'daily'\n          if completed #set OHV for completed dailies\n            task.value = task.value + obj.taskDeltaFormula(task.value, 'up')\n          (task.history ?= []).push { date: +new Date, value: task.value }\n          task.completed = false\n          paths[\"tasks.#{task.id}.value\"] = true;paths[\"tasks.#{task.id}.history\"] = true;paths[\"tasks.#{task.id}.completed\"] = true;\n\n        when 'todo'\n          #get updated value\n          absVal = if (completed) then Math.abs(task.value) else task.value\n          todoTally += absVal\n    user.habits.forEach (task) -> # slowly reset 'onlies' value to 0\n      if task.up is false or task.down is false\n        if Math.abs(task.value) < 0.1\n          task.value = 0\n        else\n          task.value = task.value / 2\n        paths[\"tasks.#{task.id}.value\"] = true\n\n\n    # Finished tallying\n    ((user.history ?= {}).todos ?= []).push { date: today, value: todoTally }\n    # tally experience\n    expTally = user.stats.exp\n    lvl = 0\n    #iterator\n    while lvl < (user.stats.lvl - 1)\n      lvl++\n      expTally += obj.tnl(lvl)\n    (user.history.exp ?= []).push { date: today, value: expTally }\n    paths[\"history\"] = true\n    user\n\n\n","_ = require 'lodash'\n\nitems = module.exports.items =\n  weapon: [\n    {index: 0, text: \"Training Sword\", classes: \"weapon_0\", notes:'Training weapon.', strength: 0, value:0}\n    {index: 1, text: \"Sword\", classes:'weapon_1', notes:'Increases experience gain by 3%.', strength: 3, value:20}\n    {index: 2, text: \"Axe\", classes:'weapon_2', notes:'Increases experience gain by 6%.', strength: 6, value:30}\n    {index: 3, text: \"Morningstar\", classes:'weapon_3', notes:'Increases experience gain by 9%.', strength: 9, value:45}\n    {index: 4, text: \"Blue Sword\", classes:'weapon_4', notes:'Increases experience gain by 12%.', strength: 12, value:65}\n    {index: 5, text: \"Red Sword\", classes:'weapon_5', notes:'Increases experience gain by 15%.', strength: 15, value:90}\n    {index: 6, text: \"Golden Sword\", classes:'weapon_6', notes:'Increases experience gain by 18%.', strength: 18, value:120}\n    {index: 7, text: \"Dark Souls Blade\", classes:'weapon_7', notes:'Increases experience gain by 21%.', strength: 21, value:150}\n  ]\n  armor: [\n    {index: 0, text: \"Cloth Armor\", classes: 'armor_0', notes:'Training armor.', defense: 0, value:0}\n    {index: 1, text: \"Leather Armor\", classes: 'armor_1', notes:'Decreases HP loss by 4%.', defense: 4, value:30}\n    {index: 2, text: \"Chain Mail\", classes: 'armor_2', notes:'Decreases HP loss by 6%.', defense: 6, value:45}\n    {index: 3, text: \"Plate Mail\", classes: 'armor_3', notes:'Decreases HP loss by 7%.', defense: 7, value:65}\n    {index: 4, text: \"Red Armor\", classes: 'armor_4', notes:'Decreases HP loss by 8%.', defense: 8, value:90}\n    {index: 5, text: \"Golden Armor\", classes: 'armor_5', notes:'Decreases HP loss by 10%.', defense: 10, value:120}\n    {index: 6, text: \"Shade Armor\", classes: 'armor_6', notes:'Decreases HP loss by 12%.', defense: 12, value:150}\n  ]\n  head: [\n    {index: 0, text: \"No Helm\", classes: 'head_0', notes:'Training helm.', defense: 0, value:0}\n    {index: 1, text: \"Leather Helm\", classes: 'head_1', notes:'Decreases HP loss by 2%.', defense: 2, value:15}\n    {index: 2, text: \"Chain Coif\", classes: 'head_2', notes:'Decreases HP loss by 3%.', defense: 3, value:25}\n    {index: 3, text: \"Plate Helm\", classes: 'head_3', notes:'Decreases HP loss by 4%.', defense: 4, value:45}\n    {index: 4, text: \"Red Helm\", classes: 'head_4', notes:'Decreases HP loss by 5%.', defense: 5, value:60}\n    {index: 5, text: \"Golden Helm\", classes: 'head_5', notes:'Decreases HP loss by 6%.', defense: 6, value:80}\n    {index: 6, text: \"Shade Helm\", classes: 'head_6', notes:'Decreases HP loss by 7%.', defense: 7, value:100}\n  ]\n  shield: [\n    {index: 0, text: \"No Shield\", classes: 'shield_0', notes:'No Shield.', defense: 0, value:0}\n    {index: 1, text: \"Wooden Shield\", classes: 'shield_1', notes:'Decreases HP loss by 3%', defense: 3, value:20}\n    {index: 2, text: \"Buckler\", classes: 'shield_2', notes:'Decreases HP loss by 4%.', defense: 4, value:35}\n    {index: 3, text: \"Enforced Shield\", classes: 'shield_3', notes:'Decreases HP loss by 5%.', defense: 5, value:55}\n    {index: 4, text: \"Red Shield\", classes: 'shield_4', notes:'Decreases HP loss by 7%.', defense: 7, value:70}\n    {index: 5, text: \"Golden Shield\", classes: 'shield_5', notes:'Decreases HP loss by 8%.', defense: 8, value:90}\n    {index: 6, text: \"Tormented Skull\", classes: 'shield_6', notes:'Decreases HP loss by 9%.', defense: 9, value:120}\n  ]\n  potion: {type: 'potion', text: \"Potion\", notes: \"Recover 15 HP (Instant Use)\", value: 25, classes: 'potion'}\n  reroll: {type: 'reroll', text: \"Re-Roll\", classes: 'reroll', notes: \"Resets your task values back to 0 (yellow). Useful when everything's red and it's hard to stay alive.\", value:0 }\n\n  pets: [\n    {text: 'Wolf', name: 'Wolf', value: 3}\n    {text: 'Tiger Cub', name: 'TigerCub', value: 3}\n    #{text: 'Polar Bear Cub', name: 'PolarBearCub', value: 3} #commented out because there are no polarbear modifiers yet, special drop?\n    {text: 'Panda Cub', name: 'PandaCub', value: 3}\n    {text: 'Lion Cub', name: 'LionCub', value: 3}\n    {text: 'Fox', name: 'Fox', value: 3}\n    {text: 'Flying Pig', name: 'FlyingPig', value: 3}\n    {text: 'Dragon', name: 'Dragon', value: 3}\n    {text: 'Cactus', name: 'Cactus', value: 3}\n    {text: 'Bear Cub', name: 'BearCub', value: 3}\n  ]\n\n  hatchingPotions: [\n    {text: 'Base', name: 'Base', notes: \"Hatches your pet in it's base form.\", value: 1}\n    {text: 'White', name: 'White', notes: 'Turns your animal into a White pet.', value: 2}\n    {text: 'Desert', name: 'Desert', notes: 'Turns your animal into a Desert pet.', value: 2}\n    {text: 'Red', name: 'Red', notes: 'Turns your animal into a Red pet.', value: 3}\n    {text: 'Shade', name: 'Shade', notes: 'Turns your animal into a Shade pet.', value: 3}\n    {text: 'Skeleton', name: 'Skeleton', notes: 'Turns your animal into a Skeleton.', value: 3}\n    {text: 'Zombie', name: 'Zombie', notes: 'Turns your animal into a Zombie.', value: 4}\n    {text: 'Cotton Candy Pink', name: 'CottonCandyPink', notes: 'Turns your animal into a Cotton Candy Pink pet.', value: 4}\n    {text: 'Cotton Candy Blue', name: 'CottonCandyBlue', notes: 'Turns your animal into a Cotton Candy Blue pet.', value: 4}\n    {text: 'Golden', name: 'Golden', notes: 'Turns your animal into a Golden pet.', value: 5}\n  ]\n\n# add \"type\" to each item, so we can reference that as \"weapon\" or \"armor\" in the html\n_.each ['weapon', 'armor', 'head', 'shield'], (key) ->\n  _.each items[key], (item) -> item.type = key\n\n_.each items.pets, (pet) -> pet.notes = 'Find a hatching potion to pour on this egg, and one day it will hatch into a loyal pet.'\n_.each items.hatchingPotions, (hatchingPotion) -> hatchingPotion.notes = \"Pour this on an egg, and it will hatch as a #{hatchingPotion.text} pet.\"\n\nmodule.exports.buyItem = (user, type, value, index) ->\n  return false if user.stats.gp < value\n  changes = {}\n  switch type\n    when 'weapon' then changes['items.weapon'] = index\n    when 'armor' then changes['items.armor'] = index\n    when 'head' then changes['items.head'] = index\n    when 'shield' then changes['items.shield'] = index\n    when 'potion'\n      hp = user.stats.hp\n      hp += 15; hp = 50 if hp > 50\n      changes['stats.hp'] = hp\n  changes['stats.gp'] = user.stats.gp - value\n  #_.each changes, (v,k) -> helpers.pathSet(k,v,user) # @yangit uncomment this i\n  return changes\n\n###\n  update store\n###\nmodule.exports.updateStore = (user) ->\n  changes = {}\n  _.each ['weapon', 'armor', 'shield', 'head'], (type) ->\n    i = parseInt(user.items?[type] || 0) + 1\n    showNext = true\n    if i is items[type].length - 1\n      if (type in ['armor', 'shield', 'head'])\n        showNext = user.backer?.tier and user.backer.tier >= 45 # backer armor\n      else\n        showNext = user.backer?.tier and user.backer.tier >= 70 # backer weapon\n    else if i is items[type].length\n      showNext = false\n    changes[type] = if showNext then items[type][i] else {hide:true}\n  return changes","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            if (ev.source === window && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","moment = require 'moment'\n_ = require 'lodash'\nalgos = require './algos.coffee'\nitems = require('./items.coffee').items\n\nsod = (timestamp, dayStart=0) ->\n  #sanity-check reset-time (is it 24h time?)\n  dayStart = 0 unless (dayStart = parseInt(dayStart)) and (0 <= dayStart <= 24)\n  moment(timestamp).startOf('day').add('h', dayStart)\n\ndayMapping = {0:'su',1:'m',2:'t',3:'w',4:'th',5:'f',6:'s'}\n\n###\n  Absolute diff between two dates\n###\ndaysBetween = (yesterday, now, dayStart) -> Math.abs sod(yesterday, dayStart).diff(now, 'days')\n\n###\n  Should the user do this taks on this date, given the task's repeat options and user.preferences.dayStart?\n###\nshouldDo = (day, repeat, dayStart=0) ->\n  return false unless repeat\n  now = +new Date\n  selected = repeat[dayMapping[sod(day, dayStart).day()]]\n  return selected unless moment(day).isSame(now,'d')\n  if dayStart <= moment(now).hour() # we're past the dayStart mark, is it due today?\n    return selected\n  else # we're not past dayStart mark, check if it was due \"yesterday\"\n    yesterday = moment(now).subtract(1,'d').day()\n    return repeat[dayMapping[yesterday]]\n\nmodule.exports =\n\n  ###\n    This allows you to set object properties by dot-path. Eg, you can run pathSet('stats.hp',50,user) which is the same as\n    user.stats.hp = 50. This is useful because in our habitrpg-shared functions we're returning changesets as {path:value},\n    so that different consumers can implement setters their own way. Derby needs model.set(path, value) for example, where\n    Angular sets object properties directly - in which case, this function will be used.\n  ###\n  dotSet: (path, val, obj) ->\n    arr = path.split('.')\n    _.reduce arr, (curr, next, index) ->\n      if (arr.length - 1) == index\n        curr[next] = val\n      curr[next]\n    , obj\n\n  dotGet: (path, obj) -> _.reduce path.split('.'), ((curr, next) -> curr[next]), obj\n\n  daysBetween: daysBetween\n\n  shouldDo: shouldDo\n\n  ###\n    Get a random property from an object\n    http://stackoverflow.com/questions/2532218/pick-random-property-from-a-javascript-object\n    returns random property (the value)\n  ###\n  randomVal: (obj) ->\n    result = undefined\n    count = 0\n    for key, val of obj\n      result = val if Math.random() < (1 / ++count)\n    result\n\n  ###\n    Remove whitespace #FIXME are we using this anywwhere? Should we be?\n  ###\n  removeWhitespace: (str) ->\n    return '' unless str\n    str.replace /\\s/g, ''\n\n  ###\n    Generate the username, since it can be one of many things: their username, their facebook fullname, their manually-set profile name\n  ###\n  username: (auth, override) ->\n    #some people define custom profile name in Avatar -> Profile\n    return override if override\n\n    if auth?.facebook?.displayName?\n      auth.facebook.displayName\n    else if auth?.facebook?\n      fb = auth.facebook\n      if fb._raw then \"#{fb.name.givenName} #{fb.name.familyName}\" else fb.name\n    else if auth?.local?\n      auth.local.username\n    else\n      'Anonymous'\n\n  ###\n    Encode the download link for .ics iCal file\n  ###\n  encodeiCalLink: (uid, apiToken) ->\n    loc = window?.location.host or process?.env?.BASE_URL or ''\n    encodeURIComponent \"http://#{loc}/v1/users/#{uid}/calendar.ics?apiToken=#{apiToken}\"\n\n  ###\n    User's currently equiped item\n  ###\n  equipped: (type, item=0, preferences={gender:'m', armorSet:'v1'}, backerTier=0) ->\n    {gender, armorSet} = preferences\n    item = parseInt(item)\n    backerTier = parseInt(backerTier)\n\n    switch type\n      when'armor'\n        if item > 5\n          return 'armor_6' if backerTier >= 45\n          item = 5 # set them back if they're trying to cheat\n        if gender is 'f'\n          return if (item is 0) then \"f_armor_#{item}_#{armorSet}\" else \"f_armor_#{item}\"\n        else\n          return \"m_armor_#{item}\"\n\n      when 'head'\n        if item > 5\n          return 'head_6' if backerTier >= 45\n          item = 5\n        if gender is 'f'\n          return if (item > 1) then \"f_head_#{item}_#{armorSet}\" else \"f_head_#{item}\"\n        else\n          return \"m_head_#{item}\"\n\n      when 'shield'\n        if item > 5\n          return 'shield_6' if backerTier >= 45\n          item = 5\n        return \"#{preferences.gender}_shield_#{item}\"\n\n      when 'weapon'\n        if item > 6\n          return 'weapon_7' if backerTier >= 70\n          item = 6\n        return \"#{preferences.gender}_weapon_#{item}\"\n\n  ###\n    Gold amount from their money\n  ###\n  gold: (num) ->\n    if num\n      return (num).toFixed(1).split('.')[0]\n    else\n      return \"0\"\n\n  ###\n    Silver amount from their money\n  ###\n  silver: (num) ->\n    if num\n      (num).toFixed(2).split('.')[1]\n    else\n      return \"00\"\n\n  ###\n    Task classes given everything about the class\n  ###\n  taskClasses: (task, filters, dayStart, lastCron, showCompleted=false) ->\n    return unless task\n    {type, completed, value, repeat} = task\n\n    # completed / remaining toggle\n    return 'hidden' if (type is 'todo') and (completed != showCompleted)\n\n    for filter, enabled of filters\n      if enabled and not task.tags?[filter]\n        # All the other classes don't matter\n        return 'hidden'\n\n    classes = type\n\n    # show as completed if completed (naturally) or not required for today\n    if type in ['todo', 'daily']\n      if completed or (type is 'daily' and !shouldDo(+new Date, task.repeat, dayStart))\n        classes += \" completed\"\n      else\n        classes += \" uncompleted\"\n    else if type is 'habit'\n      classes += ' habit-wide' if task.down and task.up\n\n    if value < -20\n      classes += ' color-worst'\n    else if value < -10\n      classes += ' color-worse'\n    else if value < -1\n      classes += ' color-bad'\n    else if value < 1\n      classes += ' color-neutral'\n    else if value < 5\n      classes += ' color-good'\n    else if value < 10\n      classes += ' color-better'\n    else\n      classes += ' color-best'\n    return classes\n\n  ###\n    Does the user own this pet?\n  ###\n  ownsPet: (pet, userPets) -> _.isArray(userPets) and userPets.indexOf(pet) != -1\n\n  ###\n    Friendly timestamp\n  ###\n  friendlyTimestamp: (timestamp) -> moment(timestamp).format('MM/DD h:mm:ss a')\n\n  ###\n    Does user have new chat messages?\n  ###\n  newChatMessages: (messages, lastMessageSeen) ->\n    return false unless messages?.length > 0\n    messages?[0] and (messages[0].id != lastMessageSeen)\n\n  ###\n    Relative Date\n  ###\n  relativeDate: require('relative-date')\n\n  ###\n    are any tags active?\n  ###\n  noTags: (tags) -> _.isEmpty(tags) or _.isEmpty(_.filter( tags, (t) -> t ) )\n\n  ###\n    Are there tags applied?\n  ###\n  appliedTags: (userTags, taskTags) ->\n    arr = []\n    _.each userTags, (t) ->\n      return unless t?\n      arr.push(t.name) if taskTags?[t.id]\n    arr.join(', ')\n\n  ###\n    User stats\n  ###\n\n  userStr: (level) -> str = (level-1) / 2\n  totalStr: (level, weapon=0) ->\n    str = (level-1) / 2\n    totalStr = (str + items.weapon[weapon].strength)\n  userDef: (level) -> def = (level-1) / 2\n  totalDef: (level, armor=0, helm=0, shield=0) ->\n    def = (level-1) / 2\n    totalDef = (def + items.armor[armor].defense + items.head[helm].defense + items.shield[shield].defense)\n  itemText: (type, item=0) -> items[type][parseInt(item)].text\n  itemStat: (type, item=0) -> if type is 'weapon' then items[type][parseInt(item)].strength else items[type][parseInt(item)].defense","(function(){// moment.js\n// version : 2.0.0\n// author : Tim Wood\n// license : MIT\n// momentjs.com\n\n(function (undefined) {\n\n    /************************************\n        Constants\n    ************************************/\n\n    var moment,\n        VERSION = \"2.0.0\",\n        round = Math.round, i,\n        // internal storage for language config files\n        languages = {},\n\n        // check for nodeJS\n        hasModule = (typeof module !== 'undefined' && module.exports),\n\n        // ASP.NET json date format regex\n        aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i,\n\n        // format tokens\n        formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|YYYYY|YYYY|YY|a|A|hh?|HH?|mm?|ss?|SS?S?|X|zz?|ZZ?|.)/g,\n        localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LT|LL?L?L?|l{1,4})/g,\n\n        // parsing tokens\n        parseMultipleFormatChunker = /([0-9a-zA-Z\\u00A0-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+)/gi,\n\n        // parsing token regexes\n        parseTokenOneOrTwoDigits = /\\d\\d?/, // 0 - 99\n        parseTokenOneToThreeDigits = /\\d{1,3}/, // 0 - 999\n        parseTokenThreeDigits = /\\d{3}/, // 000 - 999\n        parseTokenFourDigits = /\\d{1,4}/, // 0 - 9999\n        parseTokenSixDigits = /[+\\-]?\\d{1,6}/, // -999,999 - 999,999\n        parseTokenWord = /[0-9]*[a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF]+\\s*?[\\u0600-\\u06FF]+/i, // any word (or two) characters or numbers including two word month in arabic.\n        parseTokenTimezone = /Z|[\\+\\-]\\d\\d:?\\d\\d/i, // +00:00 -00:00 +0000 -0000 or Z\n        parseTokenT = /T/i, // T (ISO seperator)\n        parseTokenTimestampMs = /[\\+\\-]?\\d+(\\.\\d{1,3})?/, // 123456789 123456789.123\n\n        // preliminary iso regex\n        // 0000-00-00 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000\n        isoRegex = /^\\s*\\d{4}-\\d\\d-\\d\\d((T| )(\\d\\d(:\\d\\d(:\\d\\d(\\.\\d\\d?\\d?)?)?)?)?([\\+\\-]\\d\\d:?\\d\\d)?)?/,\n        isoFormat = 'YYYY-MM-DDTHH:mm:ssZ',\n\n        // iso time formats and regexes\n        isoTimes = [\n            ['HH:mm:ss.S', /(T| )\\d\\d:\\d\\d:\\d\\d\\.\\d{1,3}/],\n            ['HH:mm:ss', /(T| )\\d\\d:\\d\\d:\\d\\d/],\n            ['HH:mm', /(T| )\\d\\d:\\d\\d/],\n            ['HH', /(T| )\\d\\d/]\n        ],\n\n        // timezone chunker \"+10:00\" > [\"10\", \"00\"] or \"-1530\" > [\"-15\", \"30\"]\n        parseTimezoneChunker = /([\\+\\-]|\\d\\d)/gi,\n\n        // getter and setter names\n        proxyGettersAndSetters = 'Month|Date|Hours|Minutes|Seconds|Milliseconds'.split('|'),\n        unitMillisecondFactors = {\n            'Milliseconds' : 1,\n            'Seconds' : 1e3,\n            'Minutes' : 6e4,\n            'Hours' : 36e5,\n            'Days' : 864e5,\n            'Months' : 2592e6,\n            'Years' : 31536e6\n        },\n\n        // format function strings\n        formatFunctions = {},\n\n        // tokens to ordinalize and pad\n        ordinalizeTokens = 'DDD w W M D d'.split(' '),\n        paddedTokens = 'M D H h m s w W'.split(' '),\n\n        formatTokenFunctions = {\n            M    : function () {\n                return this.month() + 1;\n            },\n            MMM  : function (format) {\n                return this.lang().monthsShort(this, format);\n            },\n            MMMM : function (format) {\n                return this.lang().months(this, format);\n            },\n            D    : function () {\n                return this.date();\n            },\n            DDD  : function () {\n                return this.dayOfYear();\n            },\n            d    : function () {\n                return this.day();\n            },\n            dd   : function (format) {\n                return this.lang().weekdaysMin(this, format);\n            },\n            ddd  : function (format) {\n                return this.lang().weekdaysShort(this, format);\n            },\n            dddd : function (format) {\n                return this.lang().weekdays(this, format);\n            },\n            w    : function () {\n                return this.week();\n            },\n            W    : function () {\n                return this.isoWeek();\n            },\n            YY   : function () {\n                return leftZeroFill(this.year() % 100, 2);\n            },\n            YYYY : function () {\n                return leftZeroFill(this.year(), 4);\n            },\n            YYYYY : function () {\n                return leftZeroFill(this.year(), 5);\n            },\n            a    : function () {\n                return this.lang().meridiem(this.hours(), this.minutes(), true);\n            },\n            A    : function () {\n                return this.lang().meridiem(this.hours(), this.minutes(), false);\n            },\n            H    : function () {\n                return this.hours();\n            },\n            h    : function () {\n                return this.hours() % 12 || 12;\n            },\n            m    : function () {\n                return this.minutes();\n            },\n            s    : function () {\n                return this.seconds();\n            },\n            S    : function () {\n                return ~~(this.milliseconds() / 100);\n            },\n            SS   : function () {\n                return leftZeroFill(~~(this.milliseconds() / 10), 2);\n            },\n            SSS  : function () {\n                return leftZeroFill(this.milliseconds(), 3);\n            },\n            Z    : function () {\n                var a = -this.zone(),\n                    b = \"+\";\n                if (a < 0) {\n                    a = -a;\n                    b = \"-\";\n                }\n                return b + leftZeroFill(~~(a / 60), 2) + \":\" + leftZeroFill(~~a % 60, 2);\n            },\n            ZZ   : function () {\n                var a = -this.zone(),\n                    b = \"+\";\n                if (a < 0) {\n                    a = -a;\n                    b = \"-\";\n                }\n                return b + leftZeroFill(~~(10 * a / 6), 4);\n            },\n            X    : function () {\n                return this.unix();\n            }\n        };\n\n    function padToken(func, count) {\n        return function (a) {\n            return leftZeroFill(func.call(this, a), count);\n        };\n    }\n    function ordinalizeToken(func) {\n        return function (a) {\n            return this.lang().ordinal(func.call(this, a));\n        };\n    }\n\n    while (ordinalizeTokens.length) {\n        i = ordinalizeTokens.pop();\n        formatTokenFunctions[i + 'o'] = ordinalizeToken(formatTokenFunctions[i]);\n    }\n    while (paddedTokens.length) {\n        i = paddedTokens.pop();\n        formatTokenFunctions[i + i] = padToken(formatTokenFunctions[i], 2);\n    }\n    formatTokenFunctions.DDDD = padToken(formatTokenFunctions.DDD, 3);\n\n\n    /************************************\n        Constructors\n    ************************************/\n\n    function Language() {\n\n    }\n\n    // Moment prototype object\n    function Moment(config) {\n        extend(this, config);\n    }\n\n    // Duration Constructor\n    function Duration(duration) {\n        var data = this._data = {},\n            years = duration.years || duration.year || duration.y || 0,\n            months = duration.months || duration.month || duration.M || 0,\n            weeks = duration.weeks || duration.week || duration.w || 0,\n            days = duration.days || duration.day || duration.d || 0,\n            hours = duration.hours || duration.hour || duration.h || 0,\n            minutes = duration.minutes || duration.minute || duration.m || 0,\n            seconds = duration.seconds || duration.second || duration.s || 0,\n            milliseconds = duration.milliseconds || duration.millisecond || duration.ms || 0;\n\n        // representation for dateAddRemove\n        this._milliseconds = milliseconds +\n            seconds * 1e3 + // 1000\n            minutes * 6e4 + // 1000 * 60\n            hours * 36e5; // 1000 * 60 * 60\n        // Because of dateAddRemove treats 24 hours as different from a\n        // day when working around DST, we need to store them separately\n        this._days = days +\n            weeks * 7;\n        // It is impossible translate months into days without knowing\n        // which months you are are talking about, so we have to store\n        // it separately.\n        this._months = months +\n            years * 12;\n\n        // The following code bubbles up values, see the tests for\n        // examples of what that means.\n        data.milliseconds = milliseconds % 1000;\n        seconds += absRound(milliseconds / 1000);\n\n        data.seconds = seconds % 60;\n        minutes += absRound(seconds / 60);\n\n        data.minutes = minutes % 60;\n        hours += absRound(minutes / 60);\n\n        data.hours = hours % 24;\n        days += absRound(hours / 24);\n\n        days += weeks * 7;\n        data.days = days % 30;\n\n        months += absRound(days / 30);\n\n        data.months = months % 12;\n        years += absRound(months / 12);\n\n        data.years = years;\n    }\n\n\n    /************************************\n        Helpers\n    ************************************/\n\n\n    function extend(a, b) {\n        for (var i in b) {\n            if (b.hasOwnProperty(i)) {\n                a[i] = b[i];\n            }\n        }\n        return a;\n    }\n\n    function absRound(number) {\n        if (number < 0) {\n            return Math.ceil(number);\n        } else {\n            return Math.floor(number);\n        }\n    }\n\n    // left zero fill a number\n    // see http://jsperf.com/left-zero-filling for performance comparison\n    function leftZeroFill(number, targetLength) {\n        var output = number + '';\n        while (output.length < targetLength) {\n            output = '0' + output;\n        }\n        return output;\n    }\n\n    // helper function for _.addTime and _.subtractTime\n    function addOrSubtractDurationFromMoment(mom, duration, isAdding) {\n        var ms = duration._milliseconds,\n            d = duration._days,\n            M = duration._months,\n            currentDate;\n\n        if (ms) {\n            mom._d.setTime(+mom + ms * isAdding);\n        }\n        if (d) {\n            mom.date(mom.date() + d * isAdding);\n        }\n        if (M) {\n            currentDate = mom.date();\n            mom.date(1)\n                .month(mom.month() + M * isAdding)\n                .date(Math.min(currentDate, mom.daysInMonth()));\n        }\n    }\n\n    // check if is an array\n    function isArray(input) {\n        return Object.prototype.toString.call(input) === '[object Array]';\n    }\n\n    // compare two arrays, return the number of differences\n    function compareArrays(array1, array2) {\n        var len = Math.min(array1.length, array2.length),\n            lengthDiff = Math.abs(array1.length - array2.length),\n            diffs = 0,\n            i;\n        for (i = 0; i < len; i++) {\n            if (~~array1[i] !== ~~array2[i]) {\n                diffs++;\n            }\n        }\n        return diffs + lengthDiff;\n    }\n\n\n    /************************************\n        Languages\n    ************************************/\n\n\n    Language.prototype = {\n        set : function (config) {\n            var prop, i;\n            for (i in config) {\n                prop = config[i];\n                if (typeof prop === 'function') {\n                    this[i] = prop;\n                } else {\n                    this['_' + i] = prop;\n                }\n            }\n        },\n\n        _months : \"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\"),\n        months : function (m) {\n            return this._months[m.month()];\n        },\n\n        _monthsShort : \"Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec\".split(\"_\"),\n        monthsShort : function (m) {\n            return this._monthsShort[m.month()];\n        },\n\n        monthsParse : function (monthName) {\n            var i, mom, regex, output;\n\n            if (!this._monthsParse) {\n                this._monthsParse = [];\n            }\n\n            for (i = 0; i < 12; i++) {\n                // make the regex if we don't have it already\n                if (!this._monthsParse[i]) {\n                    mom = moment([2000, i]);\n                    regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n                    this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n                }\n                // test the regex\n                if (this._monthsParse[i].test(monthName)) {\n                    return i;\n                }\n            }\n        },\n\n        _weekdays : \"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),\n        weekdays : function (m) {\n            return this._weekdays[m.day()];\n        },\n\n        _weekdaysShort : \"Sun_Mon_Tue_Wed_Thu_Fri_Sat\".split(\"_\"),\n        weekdaysShort : function (m) {\n            return this._weekdaysShort[m.day()];\n        },\n\n        _weekdaysMin : \"Su_Mo_Tu_We_Th_Fr_Sa\".split(\"_\"),\n        weekdaysMin : function (m) {\n            return this._weekdaysMin[m.day()];\n        },\n\n        _longDateFormat : {\n            LT : \"h:mm A\",\n            L : \"MM/DD/YYYY\",\n            LL : \"MMMM D YYYY\",\n            LLL : \"MMMM D YYYY LT\",\n            LLLL : \"dddd, MMMM D YYYY LT\"\n        },\n        longDateFormat : function (key) {\n            var output = this._longDateFormat[key];\n            if (!output && this._longDateFormat[key.toUpperCase()]) {\n                output = this._longDateFormat[key.toUpperCase()].replace(/MMMM|MM|DD|dddd/g, function (val) {\n                    return val.slice(1);\n                });\n                this._longDateFormat[key] = output;\n            }\n            return output;\n        },\n\n        meridiem : function (hours, minutes, isLower) {\n            if (hours > 11) {\n                return isLower ? 'pm' : 'PM';\n            } else {\n                return isLower ? 'am' : 'AM';\n            }\n        },\n\n        _calendar : {\n            sameDay : '[Today at] LT',\n            nextDay : '[Tomorrow at] LT',\n            nextWeek : 'dddd [at] LT',\n            lastDay : '[Yesterday at] LT',\n            lastWeek : '[last] dddd [at] LT',\n            sameElse : 'L'\n        },\n        calendar : function (key, mom) {\n            var output = this._calendar[key];\n            return typeof output === 'function' ? output.apply(mom) : output;\n        },\n\n        _relativeTime : {\n            future : \"in %s\",\n            past : \"%s ago\",\n            s : \"a few seconds\",\n            m : \"a minute\",\n            mm : \"%d minutes\",\n            h : \"an hour\",\n            hh : \"%d hours\",\n            d : \"a day\",\n            dd : \"%d days\",\n            M : \"a month\",\n            MM : \"%d months\",\n            y : \"a year\",\n            yy : \"%d years\"\n        },\n        relativeTime : function (number, withoutSuffix, string, isFuture) {\n            var output = this._relativeTime[string];\n            return (typeof output === 'function') ?\n                output(number, withoutSuffix, string, isFuture) :\n                output.replace(/%d/i, number);\n        },\n        pastFuture : function (diff, output) {\n            var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n            return typeof format === 'function' ? format(output) : format.replace(/%s/i, output);\n        },\n\n        ordinal : function (number) {\n            return this._ordinal.replace(\"%d\", number);\n        },\n        _ordinal : \"%d\",\n\n        preparse : function (string) {\n            return string;\n        },\n\n        postformat : function (string) {\n            return string;\n        },\n\n        week : function (mom) {\n            return weekOfYear(mom, this._week.dow, this._week.doy);\n        },\n        _week : {\n            dow : 0, // Sunday is the first day of the week.\n            doy : 6  // The week that contains Jan 1st is the first week of the year.\n        }\n    };\n\n    // Loads a language definition into the `languages` cache.  The function\n    // takes a key and optionally values.  If not in the browser and no values\n    // are provided, it will load the language file module.  As a convenience,\n    // this function also returns the language values.\n    function loadLang(key, values) {\n        values.abbr = key;\n        if (!languages[key]) {\n            languages[key] = new Language();\n        }\n        languages[key].set(values);\n        return languages[key];\n    }\n\n    // Determines which language definition to use and returns it.\n    //\n    // With no parameters, it will return the global language.  If you\n    // pass in a language key, such as 'en', it will return the\n    // definition for 'en', so long as 'en' has already been loaded using\n    // moment.lang.\n    function getLangDefinition(key) {\n        if (!key) {\n            return moment.fn._lang;\n        }\n        if (!languages[key] && hasModule) {\n            require('./lang/' + key);\n        }\n        return languages[key];\n    }\n\n\n    /************************************\n        Formatting\n    ************************************/\n\n\n    function removeFormattingTokens(input) {\n        if (input.match(/\\[.*\\]/)) {\n            return input.replace(/^\\[|\\]$/g, \"\");\n        }\n        return input.replace(/\\\\/g, \"\");\n    }\n\n    function makeFormatFunction(format) {\n        var array = format.match(formattingTokens), i, length;\n\n        for (i = 0, length = array.length; i < length; i++) {\n            if (formatTokenFunctions[array[i]]) {\n                array[i] = formatTokenFunctions[array[i]];\n            } else {\n                array[i] = removeFormattingTokens(array[i]);\n            }\n        }\n\n        return function (mom) {\n            var output = \"\";\n            for (i = 0; i < length; i++) {\n                output += typeof array[i].call === 'function' ? array[i].call(mom, format) : array[i];\n            }\n            return output;\n        };\n    }\n\n    // format date using native date object\n    function formatMoment(m, format) {\n        var i = 5;\n\n        function replaceLongDateFormatTokens(input) {\n            return m.lang().longDateFormat(input) || input;\n        }\n\n        while (i-- && localFormattingTokens.test(format)) {\n            format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n        }\n\n        if (!formatFunctions[format]) {\n            formatFunctions[format] = makeFormatFunction(format);\n        }\n\n        return formatFunctions[format](m);\n    }\n\n\n    /************************************\n        Parsing\n    ************************************/\n\n\n    // get the regex to find the next token\n    function getParseRegexForToken(token) {\n        switch (token) {\n        case 'DDDD':\n            return parseTokenThreeDigits;\n        case 'YYYY':\n            return parseTokenFourDigits;\n        case 'YYYYY':\n            return parseTokenSixDigits;\n        case 'S':\n        case 'SS':\n        case 'SSS':\n        case 'DDD':\n            return parseTokenOneToThreeDigits;\n        case 'MMM':\n        case 'MMMM':\n        case 'dd':\n        case 'ddd':\n        case 'dddd':\n        case 'a':\n        case 'A':\n            return parseTokenWord;\n        case 'X':\n            return parseTokenTimestampMs;\n        case 'Z':\n        case 'ZZ':\n            return parseTokenTimezone;\n        case 'T':\n            return parseTokenT;\n        case 'MM':\n        case 'DD':\n        case 'YY':\n        case 'HH':\n        case 'hh':\n        case 'mm':\n        case 'ss':\n        case 'M':\n        case 'D':\n        case 'd':\n        case 'H':\n        case 'h':\n        case 'm':\n        case 's':\n            return parseTokenOneOrTwoDigits;\n        default :\n            return new RegExp(token.replace('\\\\', ''));\n        }\n    }\n\n    // function to convert string input to date\n    function addTimeToArrayFromToken(token, input, config) {\n        var a, b,\n            datePartArray = config._a;\n\n        switch (token) {\n        // MONTH\n        case 'M' : // fall through to MM\n        case 'MM' :\n            datePartArray[1] = (input == null) ? 0 : ~~input - 1;\n            break;\n        case 'MMM' : // fall through to MMMM\n        case 'MMMM' :\n            a = getLangDefinition(config._l).monthsParse(input);\n            // if we didn't find a month name, mark the date as invalid.\n            if (a != null) {\n                datePartArray[1] = a;\n            } else {\n                config._isValid = false;\n            }\n            break;\n        // DAY OF MONTH\n        case 'D' : // fall through to DDDD\n        case 'DD' : // fall through to DDDD\n        case 'DDD' : // fall through to DDDD\n        case 'DDDD' :\n            if (input != null) {\n                datePartArray[2] = ~~input;\n            }\n            break;\n        // YEAR\n        case 'YY' :\n            datePartArray[0] = ~~input + (~~input > 68 ? 1900 : 2000);\n            break;\n        case 'YYYY' :\n        case 'YYYYY' :\n            datePartArray[0] = ~~input;\n            break;\n        // AM / PM\n        case 'a' : // fall through to A\n        case 'A' :\n            config._isPm = ((input + '').toLowerCase() === 'pm');\n            break;\n        // 24 HOUR\n        case 'H' : // fall through to hh\n        case 'HH' : // fall through to hh\n        case 'h' : // fall through to hh\n        case 'hh' :\n            datePartArray[3] = ~~input;\n            break;\n        // MINUTE\n        case 'm' : // fall through to mm\n        case 'mm' :\n            datePartArray[4] = ~~input;\n            break;\n        // SECOND\n        case 's' : // fall through to ss\n        case 'ss' :\n            datePartArray[5] = ~~input;\n            break;\n        // MILLISECOND\n        case 'S' :\n        case 'SS' :\n        case 'SSS' :\n            datePartArray[6] = ~~ (('0.' + input) * 1000);\n            break;\n        // UNIX TIMESTAMP WITH MS\n        case 'X':\n            config._d = new Date(parseFloat(input) * 1000);\n            break;\n        // TIMEZONE\n        case 'Z' : // fall through to ZZ\n        case 'ZZ' :\n            config._useUTC = true;\n            a = (input + '').match(parseTimezoneChunker);\n            if (a && a[1]) {\n                config._tzh = ~~a[1];\n            }\n            if (a && a[2]) {\n                config._tzm = ~~a[2];\n            }\n            // reverse offsets\n            if (a && a[0] === '+') {\n                config._tzh = -config._tzh;\n                config._tzm = -config._tzm;\n            }\n            break;\n        }\n\n        // if the input is null, the date is not valid\n        if (input == null) {\n            config._isValid = false;\n        }\n    }\n\n    // convert an array to a date.\n    // the array should mirror the parameters below\n    // note: all values past the year are optional and will default to the lowest possible value.\n    // [year, month, day , hour, minute, second, millisecond]\n    function dateFromArray(config) {\n        var i, date, input = [];\n\n        if (config._d) {\n            return;\n        }\n\n        for (i = 0; i < 7; i++) {\n            config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n        }\n\n        // add the offsets to the time to be parsed so that we can have a clean array for checking isValid\n        input[3] += config._tzh || 0;\n        input[4] += config._tzm || 0;\n\n        date = new Date(0);\n\n        if (config._useUTC) {\n            date.setUTCFullYear(input[0], input[1], input[2]);\n            date.setUTCHours(input[3], input[4], input[5], input[6]);\n        } else {\n            date.setFullYear(input[0], input[1], input[2]);\n            date.setHours(input[3], input[4], input[5], input[6]);\n        }\n\n        config._d = date;\n    }\n\n    // date from string and format string\n    function makeDateFromStringAndFormat(config) {\n        // This array is used to make a Date, either with `new Date` or `Date.UTC`\n        var tokens = config._f.match(formattingTokens),\n            string = config._i,\n            i, parsedInput;\n\n        config._a = [];\n\n        for (i = 0; i < tokens.length; i++) {\n            parsedInput = (getParseRegexForToken(tokens[i]).exec(string) || [])[0];\n            if (parsedInput) {\n                string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n            }\n            // don't parse if its not a known token\n            if (formatTokenFunctions[tokens[i]]) {\n                addTimeToArrayFromToken(tokens[i], parsedInput, config);\n            }\n        }\n        // handle am pm\n        if (config._isPm && config._a[3] < 12) {\n            config._a[3] += 12;\n        }\n        // if is 12 am, change hours to 0\n        if (config._isPm === false && config._a[3] === 12) {\n            config._a[3] = 0;\n        }\n        // return\n        dateFromArray(config);\n    }\n\n    // date from string and array of format strings\n    function makeDateFromStringAndArray(config) {\n        var tempConfig,\n            tempMoment,\n            bestMoment,\n\n            scoreToBeat = 99,\n            i,\n            currentDate,\n            currentScore;\n\n        while (config._f.length) {\n            tempConfig = extend({}, config);\n            tempConfig._f = config._f.pop();\n            makeDateFromStringAndFormat(tempConfig);\n            tempMoment = new Moment(tempConfig);\n\n            if (tempMoment.isValid()) {\n                bestMoment = tempMoment;\n                break;\n            }\n\n            currentScore = compareArrays(tempConfig._a, tempMoment.toArray());\n\n            if (currentScore < scoreToBeat) {\n                scoreToBeat = currentScore;\n                bestMoment = tempMoment;\n            }\n        }\n\n        extend(config, bestMoment);\n    }\n\n    // date from iso format\n    function makeDateFromString(config) {\n        var i,\n            string = config._i;\n        if (isoRegex.exec(string)) {\n            config._f = 'YYYY-MM-DDT';\n            for (i = 0; i < 4; i++) {\n                if (isoTimes[i][1].exec(string)) {\n                    config._f += isoTimes[i][0];\n                    break;\n                }\n            }\n            if (parseTokenTimezone.exec(string)) {\n                config._f += \" Z\";\n            }\n            makeDateFromStringAndFormat(config);\n        } else {\n            config._d = new Date(string);\n        }\n    }\n\n    function makeDateFromInput(config) {\n        var input = config._i,\n            matched = aspNetJsonRegex.exec(input);\n\n        if (input === undefined) {\n            config._d = new Date();\n        } else if (matched) {\n            config._d = new Date(+matched[1]);\n        } else if (typeof input === 'string') {\n            makeDateFromString(config);\n        } else if (isArray(input)) {\n            config._a = input.slice(0);\n            dateFromArray(config);\n        } else {\n            config._d = input instanceof Date ? new Date(+input) : new Date(input);\n        }\n    }\n\n\n    /************************************\n        Relative Time\n    ************************************/\n\n\n    // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\n    function substituteTimeAgo(string, number, withoutSuffix, isFuture, lang) {\n        return lang.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n    }\n\n    function relativeTime(milliseconds, withoutSuffix, lang) {\n        var seconds = round(Math.abs(milliseconds) / 1000),\n            minutes = round(seconds / 60),\n            hours = round(minutes / 60),\n            days = round(hours / 24),\n            years = round(days / 365),\n            args = seconds < 45 && ['s', seconds] ||\n                minutes === 1 && ['m'] ||\n                minutes < 45 && ['mm', minutes] ||\n                hours === 1 && ['h'] ||\n                hours < 22 && ['hh', hours] ||\n                days === 1 && ['d'] ||\n                days <= 25 && ['dd', days] ||\n                days <= 45 && ['M'] ||\n                days < 345 && ['MM', round(days / 30)] ||\n                years === 1 && ['y'] || ['yy', years];\n        args[2] = withoutSuffix;\n        args[3] = milliseconds > 0;\n        args[4] = lang;\n        return substituteTimeAgo.apply({}, args);\n    }\n\n\n    /************************************\n        Week of Year\n    ************************************/\n\n\n    // firstDayOfWeek       0 = sun, 6 = sat\n    //                      the day of the week that starts the week\n    //                      (usually sunday or monday)\n    // firstDayOfWeekOfYear 0 = sun, 6 = sat\n    //                      the first week is the week that contains the first\n    //                      of this day of the week\n    //                      (eg. ISO weeks use thursday (4))\n    function weekOfYear(mom, firstDayOfWeek, firstDayOfWeekOfYear) {\n        var end = firstDayOfWeekOfYear - firstDayOfWeek,\n            daysToDayOfWeek = firstDayOfWeekOfYear - mom.day();\n\n\n        if (daysToDayOfWeek > end) {\n            daysToDayOfWeek -= 7;\n        }\n\n        if (daysToDayOfWeek < end - 7) {\n            daysToDayOfWeek += 7;\n        }\n\n        return Math.ceil(moment(mom).add('d', daysToDayOfWeek).dayOfYear() / 7);\n    }\n\n\n    /************************************\n        Top Level Functions\n    ************************************/\n\n    function makeMoment(config) {\n        var input = config._i,\n            format = config._f;\n\n        if (input === null || input === '') {\n            return null;\n        }\n\n        if (typeof input === 'string') {\n            config._i = input = getLangDefinition().preparse(input);\n        }\n\n        if (moment.isMoment(input)) {\n            config = extend({}, input);\n            config._d = new Date(+input._d);\n        } else if (format) {\n            if (isArray(format)) {\n                makeDateFromStringAndArray(config);\n            } else {\n                makeDateFromStringAndFormat(config);\n            }\n        } else {\n            makeDateFromInput(config);\n        }\n\n        return new Moment(config);\n    }\n\n    moment = function (input, format, lang) {\n        return makeMoment({\n            _i : input,\n            _f : format,\n            _l : lang,\n            _isUTC : false\n        });\n    };\n\n    // creating with utc\n    moment.utc = function (input, format, lang) {\n        return makeMoment({\n            _useUTC : true,\n            _isUTC : true,\n            _l : lang,\n            _i : input,\n            _f : format\n        });\n    };\n\n    // creating with unix timestamp (in seconds)\n    moment.unix = function (input) {\n        return moment(input * 1000);\n    };\n\n    // duration\n    moment.duration = function (input, key) {\n        var isDuration = moment.isDuration(input),\n            isNumber = (typeof input === 'number'),\n            duration = (isDuration ? input._data : (isNumber ? {} : input)),\n            ret;\n\n        if (isNumber) {\n            if (key) {\n                duration[key] = input;\n            } else {\n                duration.milliseconds = input;\n            }\n        }\n\n        ret = new Duration(duration);\n\n        if (isDuration && input.hasOwnProperty('_lang')) {\n            ret._lang = input._lang;\n        }\n\n        return ret;\n    };\n\n    // version number\n    moment.version = VERSION;\n\n    // default format\n    moment.defaultFormat = isoFormat;\n\n    // This function will load languages and then set the global language.  If\n    // no arguments are passed in, it will simply return the current global\n    // language key.\n    moment.lang = function (key, values) {\n        var i;\n\n        if (!key) {\n            return moment.fn._lang._abbr;\n        }\n        if (values) {\n            loadLang(key, values);\n        } else if (!languages[key]) {\n            getLangDefinition(key);\n        }\n        moment.duration.fn._lang = moment.fn._lang = getLangDefinition(key);\n    };\n\n    // returns language data\n    moment.langData = function (key) {\n        if (key && key._lang && key._lang._abbr) {\n            key = key._lang._abbr;\n        }\n        return getLangDefinition(key);\n    };\n\n    // compare moment object\n    moment.isMoment = function (obj) {\n        return obj instanceof Moment;\n    };\n\n    // for typechecking Duration objects\n    moment.isDuration = function (obj) {\n        return obj instanceof Duration;\n    };\n\n\n    /************************************\n        Moment Prototype\n    ************************************/\n\n\n    moment.fn = Moment.prototype = {\n\n        clone : function () {\n            return moment(this);\n        },\n\n        valueOf : function () {\n            return +this._d;\n        },\n\n        unix : function () {\n            return Math.floor(+this._d / 1000);\n        },\n\n        toString : function () {\n            return this.format(\"ddd MMM DD YYYY HH:mm:ss [GMT]ZZ\");\n        },\n\n        toDate : function () {\n            return this._d;\n        },\n\n        toJSON : function () {\n            return moment.utc(this).format('YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n        },\n\n        toArray : function () {\n            var m = this;\n            return [\n                m.year(),\n                m.month(),\n                m.date(),\n                m.hours(),\n                m.minutes(),\n                m.seconds(),\n                m.milliseconds()\n            ];\n        },\n\n        isValid : function () {\n            if (this._isValid == null) {\n                if (this._a) {\n                    this._isValid = !compareArrays(this._a, (this._isUTC ? moment.utc(this._a) : moment(this._a)).toArray());\n                } else {\n                    this._isValid = !isNaN(this._d.getTime());\n                }\n            }\n            return !!this._isValid;\n        },\n\n        utc : function () {\n            this._isUTC = true;\n            return this;\n        },\n\n        local : function () {\n            this._isUTC = false;\n            return this;\n        },\n\n        format : function (inputString) {\n            var output = formatMoment(this, inputString || moment.defaultFormat);\n            return this.lang().postformat(output);\n        },\n\n        add : function (input, val) {\n            var dur;\n            // switch args to support add('s', 1) and add(1, 's')\n            if (typeof input === 'string') {\n                dur = moment.duration(+val, input);\n            } else {\n                dur = moment.duration(input, val);\n            }\n            addOrSubtractDurationFromMoment(this, dur, 1);\n            return this;\n        },\n\n        subtract : function (input, val) {\n            var dur;\n            // switch args to support subtract('s', 1) and subtract(1, 's')\n            if (typeof input === 'string') {\n                dur = moment.duration(+val, input);\n            } else {\n                dur = moment.duration(input, val);\n            }\n            addOrSubtractDurationFromMoment(this, dur, -1);\n            return this;\n        },\n\n        diff : function (input, units, asFloat) {\n            var that = this._isUTC ? moment(input).utc() : moment(input).local(),\n                zoneDiff = (this.zone() - that.zone()) * 6e4,\n                diff, output;\n\n            if (units) {\n                // standardize on singular form\n                units = units.replace(/s$/, '');\n            }\n\n            if (units === 'year' || units === 'month') {\n                diff = (this.daysInMonth() + that.daysInMonth()) * 432e5; // 24 * 60 * 60 * 1000 / 2\n                output = ((this.year() - that.year()) * 12) + (this.month() - that.month());\n                output += ((this - moment(this).startOf('month')) - (that - moment(that).startOf('month'))) / diff;\n                if (units === 'year') {\n                    output = output / 12;\n                }\n            } else {\n                diff = (this - that) - zoneDiff;\n                output = units === 'second' ? diff / 1e3 : // 1000\n                    units === 'minute' ? diff / 6e4 : // 1000 * 60\n                    units === 'hour' ? diff / 36e5 : // 1000 * 60 * 60\n                    units === 'day' ? diff / 864e5 : // 1000 * 60 * 60 * 24\n                    units === 'week' ? diff / 6048e5 : // 1000 * 60 * 60 * 24 * 7\n                    diff;\n            }\n            return asFloat ? output : absRound(output);\n        },\n\n        from : function (time, withoutSuffix) {\n            return moment.duration(this.diff(time)).lang(this.lang()._abbr).humanize(!withoutSuffix);\n        },\n\n        fromNow : function (withoutSuffix) {\n            return this.from(moment(), withoutSuffix);\n        },\n\n        calendar : function () {\n            var diff = this.diff(moment().startOf('day'), 'days', true),\n                format = diff < -6 ? 'sameElse' :\n                diff < -1 ? 'lastWeek' :\n                diff < 0 ? 'lastDay' :\n                diff < 1 ? 'sameDay' :\n                diff < 2 ? 'nextDay' :\n                diff < 7 ? 'nextWeek' : 'sameElse';\n            return this.format(this.lang().calendar(format, this));\n        },\n\n        isLeapYear : function () {\n            var year = this.year();\n            return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n        },\n\n        isDST : function () {\n            return (this.zone() < moment([this.year()]).zone() ||\n                this.zone() < moment([this.year(), 5]).zone());\n        },\n\n        day : function (input) {\n            var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n            return input == null ? day :\n                this.add({ d : input - day });\n        },\n\n        startOf: function (units) {\n            units = units.replace(/s$/, '');\n            // the following switch intentionally omits break keywords\n            // to utilize falling through the cases.\n            switch (units) {\n            case 'year':\n                this.month(0);\n                /* falls through */\n            case 'month':\n                this.date(1);\n                /* falls through */\n            case 'week':\n            case 'day':\n                this.hours(0);\n                /* falls through */\n            case 'hour':\n                this.minutes(0);\n                /* falls through */\n            case 'minute':\n                this.seconds(0);\n                /* falls through */\n            case 'second':\n                this.milliseconds(0);\n                /* falls through */\n            }\n\n            // weeks are a special case\n            if (units === 'week') {\n                this.day(0);\n            }\n\n            return this;\n        },\n\n        endOf: function (units) {\n            return this.startOf(units).add(units.replace(/s?$/, 's'), 1).subtract('ms', 1);\n        },\n\n        isAfter: function (input, units) {\n            units = typeof units !== 'undefined' ? units : 'millisecond';\n            return +this.clone().startOf(units) > +moment(input).startOf(units);\n        },\n\n        isBefore: function (input, units) {\n            units = typeof units !== 'undefined' ? units : 'millisecond';\n            return +this.clone().startOf(units) < +moment(input).startOf(units);\n        },\n\n        isSame: function (input, units) {\n            units = typeof units !== 'undefined' ? units : 'millisecond';\n            return +this.clone().startOf(units) === +moment(input).startOf(units);\n        },\n\n        zone : function () {\n            return this._isUTC ? 0 : this._d.getTimezoneOffset();\n        },\n\n        daysInMonth : function () {\n            return moment.utc([this.year(), this.month() + 1, 0]).date();\n        },\n\n        dayOfYear : function (input) {\n            var dayOfYear = round((moment(this).startOf('day') - moment(this).startOf('year')) / 864e5) + 1;\n            return input == null ? dayOfYear : this.add(\"d\", (input - dayOfYear));\n        },\n\n        isoWeek : function (input) {\n            var week = weekOfYear(this, 1, 4);\n            return input == null ? week : this.add(\"d\", (input - week) * 7);\n        },\n\n        week : function (input) {\n            var week = this.lang().week(this);\n            return input == null ? week : this.add(\"d\", (input - week) * 7);\n        },\n\n        // If passed a language key, it will set the language for this\n        // instance.  Otherwise, it will return the language configuration\n        // variables for this instance.\n        lang : function (key) {\n            if (key === undefined) {\n                return this._lang;\n            } else {\n                this._lang = getLangDefinition(key);\n                return this;\n            }\n        }\n    };\n\n    // helper for adding shortcuts\n    function makeGetterAndSetter(name, key) {\n        moment.fn[name] = moment.fn[name + 's'] = function (input) {\n            var utc = this._isUTC ? 'UTC' : '';\n            if (input != null) {\n                this._d['set' + utc + key](input);\n                return this;\n            } else {\n                return this._d['get' + utc + key]();\n            }\n        };\n    }\n\n    // loop through and add shortcuts (Month, Date, Hours, Minutes, Seconds, Milliseconds)\n    for (i = 0; i < proxyGettersAndSetters.length; i ++) {\n        makeGetterAndSetter(proxyGettersAndSetters[i].toLowerCase().replace(/s$/, ''), proxyGettersAndSetters[i]);\n    }\n\n    // add shortcut for year (uses different syntax than the getter/setter 'year' == 'FullYear')\n    makeGetterAndSetter('year', 'FullYear');\n\n    // add plural methods\n    moment.fn.days = moment.fn.day;\n    moment.fn.weeks = moment.fn.week;\n    moment.fn.isoWeeks = moment.fn.isoWeek;\n\n    /************************************\n        Duration Prototype\n    ************************************/\n\n\n    moment.duration.fn = Duration.prototype = {\n        weeks : function () {\n            return absRound(this.days() / 7);\n        },\n\n        valueOf : function () {\n            return this._milliseconds +\n              this._days * 864e5 +\n              this._months * 2592e6;\n        },\n\n        humanize : function (withSuffix) {\n            var difference = +this,\n                output = relativeTime(difference, !withSuffix, this.lang());\n\n            if (withSuffix) {\n                output = this.lang().pastFuture(difference, output);\n            }\n\n            return this.lang().postformat(output);\n        },\n\n        lang : moment.fn.lang\n    };\n\n    function makeDurationGetter(name) {\n        moment.duration.fn[name] = function () {\n            return this._data[name];\n        };\n    }\n\n    function makeDurationAsGetter(name, factor) {\n        moment.duration.fn['as' + name] = function () {\n            return +this / factor;\n        };\n    }\n\n    for (i in unitMillisecondFactors) {\n        if (unitMillisecondFactors.hasOwnProperty(i)) {\n            makeDurationAsGetter(i, unitMillisecondFactors[i]);\n            makeDurationGetter(i.toLowerCase());\n        }\n    }\n\n    makeDurationAsGetter('Weeks', 6048e5);\n\n\n    /************************************\n        Default Lang\n    ************************************/\n\n\n    // Set default language, other languages will inherit from English.\n    moment.lang('en', {\n        ordinal : function (number) {\n            var b = number % 10,\n                output = (~~ (number % 100 / 10) === 1) ? 'th' :\n                (b === 1) ? 'st' :\n                (b === 2) ? 'nd' :\n                (b === 3) ? 'rd' : 'th';\n            return number + output;\n        }\n    });\n\n\n    /************************************\n        Exposing Moment\n    ************************************/\n\n\n    // CommonJS module is defined\n    if (hasModule) {\n        module.exports = moment;\n    }\n    /*global ender:false */\n    if (typeof ender === 'undefined') {\n        // here, `this` means `window` in the browser, or `global` on the server\n        // add `moment` as a global object via a string identifier,\n        // for Closure Compiler \"advanced\" mode\n        this['moment'] = moment;\n    }\n    /*global define:false */\n    if (typeof define === \"function\" && define.amd) {\n        define(\"moment\", [], function () {\n            return moment;\n        });\n    }\n}).call(this);\n\n})()","(function(global){/**\n * @license\n * Lo-Dash 1.2.1 (Custom Build) <http://lodash.com/>\n * Build: `lodash modern -o ./dist/lodash.js`\n * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.4.4 <http://underscorejs.org/>\n * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.\n * Available under MIT license <http://lodash.com/license>\n */\n;(function(window) {\n\n  /** Used as a safe reference for `undefined` in pre ES5 environments */\n  var undefined;\n\n  /** Detect free variable `exports` */\n  var freeExports = typeof exports == 'object' && exports;\n\n  /** Detect free variable `module` */\n  var freeModule = typeof module == 'object' && module && module.exports == freeExports && module;\n\n  /** Detect free variable `global`, from Node.js or Browserified code, and use it as `window` */\n  var freeGlobal = typeof global == 'object' && global;\n  if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {\n    window = freeGlobal;\n  }\n\n  /** Used to generate unique IDs */\n  var idCounter = 0;\n\n  /** Used internally to indicate various things */\n  var indicatorObject = {};\n\n  /** Used to prefix keys to avoid issues with `__proto__` and properties on `Object.prototype` */\n  var keyPrefix = +new Date + '';\n\n  /** Used as the size when optimizations are enabled for large arrays */\n  var largeArraySize = 200;\n\n  /** Used to match empty string literals in compiled template source */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;\n\n  /**\n   * Used to match ES6 template delimiters\n   * http://people.mozilla.org/~jorendorff/es6-draft.html#sec-7.8.6\n   */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match regexp flags from their coerced string values */\n  var reFlags = /\\w*$/;\n\n  /** Used to match \"interpolate\" template delimiters */\n  var reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to detect and test whitespace */\n  var whitespace = (\n    // whitespace\n    ' \\t\\x0B\\f\\xA0\\ufeff' +\n\n    // line terminators\n    '\\n\\r\\u2028\\u2029' +\n\n    // unicode category \"Zs\" space separators\n    '\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000'\n  );\n\n  /** Used to match leading whitespace and zeros to be removed */\n  var reLeadingSpacesAndZeros = RegExp('^[' + whitespace + ']*0+(?=.$)');\n\n  /** Used to ensure capturing order of template delimiters */\n  var reNoMatch = /($^)/;\n\n  /** Used to match HTML characters */\n  var reUnescapedHtml = /[&<>\"']/g;\n\n  /** Used to match unescaped characters in compiled string literals */\n  var reUnescapedString = /['\\n\\r\\t\\u2028\\u2029\\\\]/g;\n\n  /** Used to assign default `context` object properties */\n  var contextProps = [\n    'Array', 'Boolean', 'Date', 'Function', 'Math', 'Number', 'Object', 'RegExp',\n    'String', '_', 'attachEvent', 'clearTimeout', 'isFinite', 'isNaN', 'parseInt',\n    'setImmediate', 'setTimeout'\n  ];\n\n  /** Used to make template sourceURLs easier to identify */\n  var templateCounter = 0;\n\n  /** `Object#toString` result shortcuts */\n  var argsClass = '[object Arguments]',\n      arrayClass = '[object Array]',\n      boolClass = '[object Boolean]',\n      dateClass = '[object Date]',\n      funcClass = '[object Function]',\n      numberClass = '[object Number]',\n      objectClass = '[object Object]',\n      regexpClass = '[object RegExp]',\n      stringClass = '[object String]';\n\n  /** Used to identify object classifications that `_.clone` supports */\n  var cloneableClasses = {};\n  cloneableClasses[funcClass] = false;\n  cloneableClasses[argsClass] = cloneableClasses[arrayClass] =\n  cloneableClasses[boolClass] = cloneableClasses[dateClass] =\n  cloneableClasses[numberClass] = cloneableClasses[objectClass] =\n  cloneableClasses[regexpClass] = cloneableClasses[stringClass] = true;\n\n  /** Used to determine if values are of the language type Object */\n  var objectTypes = {\n    'boolean': false,\n    'function': true,\n    'object': true,\n    'number': false,\n    'string': false,\n    'undefined': false\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\t': 't',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new `lodash` function using the given `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @category Utilities\n   * @param {Object} [context=window] The context object.\n   * @returns {Function} Returns the `lodash` function.\n   */\n  function runInContext(context) {\n    // Avoid issues with some ES3 environments that attempt to use values, named\n    // after built-in constructors like `Object`, for the creation of literals.\n    // ES5 clears this up by stating that literals must use built-in constructors.\n    // See http://es5.github.com/#x11.1.5.\n    context = context ? _.defaults(window.Object(), context, _.pick(window, contextProps)) : window;\n\n    /** Native constructor references */\n    var Array = context.Array,\n        Boolean = context.Boolean,\n        Date = context.Date,\n        Function = context.Function,\n        Math = context.Math,\n        Number = context.Number,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for `Array` and `Object` method references */\n    var arrayRef = Array(),\n        objectRef = Object();\n\n    /** Used to restore the original `_` reference in `noConflict` */\n    var oldDash = context._;\n\n    /** Used to detect if a method is native */\n    var reNative = RegExp('^' +\n      String(objectRef.valueOf)\n        .replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n        .replace(/valueOf|for [^\\]]+/g, '.+?') + '$'\n    );\n\n    /** Native method shortcuts */\n    var ceil = Math.ceil,\n        clearTimeout = context.clearTimeout,\n        concat = arrayRef.concat,\n        floor = Math.floor,\n        getPrototypeOf = reNative.test(getPrototypeOf = Object.getPrototypeOf) && getPrototypeOf,\n        hasOwnProperty = objectRef.hasOwnProperty,\n        push = arrayRef.push,\n        setImmediate = context.setImmediate,\n        setTimeout = context.setTimeout,\n        toString = objectRef.toString;\n\n    /* Native method shortcuts for methods with the same name as other `lodash` methods */\n    var nativeBind = reNative.test(nativeBind = toString.bind) && nativeBind,\n        nativeIsArray = reNative.test(nativeIsArray = Array.isArray) && nativeIsArray,\n        nativeIsFinite = context.isFinite,\n        nativeIsNaN = context.isNaN,\n        nativeKeys = reNative.test(nativeKeys = Object.keys) && nativeKeys,\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random,\n        nativeSlice = arrayRef.slice;\n\n    /** Detect various environments */\n    var isIeOpera = reNative.test(context.attachEvent),\n        isV8 = nativeBind && !/\\n|true/.test(nativeBind + isIeOpera);\n\n    /** Used to lookup a built-in constructor by [[Class]] */\n    var ctorByClass = {};\n    ctorByClass[arrayClass] = Array;\n    ctorByClass[boolClass] = Boolean;\n    ctorByClass[dateClass] = Date;\n    ctorByClass[objectClass] = Object;\n    ctorByClass[numberClass] = Number;\n    ctorByClass[regexpClass] = RegExp;\n    ctorByClass[stringClass] = String;\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object, which wraps the given `value`, to enable method\n     * chaining.\n     *\n     * In addition to Lo-Dash methods, wrappers also have the following `Array` methods:\n     * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`, `splice`,\n     * and `unshift`\n     *\n     * Chaining is supported in custom builds as long as the `value` method is\n     * implicitly or explicitly included in the build.\n     *\n     * The chainable wrapper functions are:\n     * `after`, `assign`, `bind`, `bindAll`, `bindKey`, `chain`, `compact`,\n     * `compose`, `concat`, `countBy`, `createCallback`, `debounce`, `defaults`,\n     * `defer`, `delay`, `difference`, `filter`, `flatten`, `forEach`, `forIn`,\n     * `forOwn`, `functions`, `groupBy`, `initial`, `intersection`, `invert`,\n     * `invoke`, `keys`, `map`, `max`, `memoize`, `merge`, `min`, `object`, `omit`,\n     * `once`, `pairs`, `partial`, `partialRight`, `pick`, `pluck`, `push`, `range`,\n     * `reject`, `rest`, `reverse`, `shuffle`, `slice`, `sort`, `sortBy`, `splice`,\n     * `tap`, `throttle`, `times`, `toArray`, `union`, `uniq`, `unshift`, `unzip`,\n     * `values`, `where`, `without`, `wrap`, and `zip`\n     *\n     * The non-chainable wrapper functions are:\n     * `clone`, `cloneDeep`, `contains`, `escape`, `every`, `find`, `has`,\n     * `identity`, `indexOf`, `isArguments`, `isArray`, `isBoolean`, `isDate`,\n     * `isElement`, `isEmpty`, `isEqual`, `isFinite`, `isFunction`, `isNaN`,\n     * `isNull`, `isNumber`, `isObject`, `isPlainObject`, `isRegExp`, `isString`,\n     * `isUndefined`, `join`, `lastIndexOf`, `mixin`, `noConflict`, `parseInt`,\n     * `pop`, `random`, `reduce`, `reduceRight`, `result`, `shift`, `size`, `some`,\n     * `sortedIndex`, `runInContext`, `template`, `unescape`, `uniqueId`, and `value`\n     *\n     * The wrapper functions `first` and `last` return wrapped values when `n` is\n     * passed, otherwise they return unwrapped values.\n     *\n     * @name _\n     * @constructor\n     * @category Chaining\n     * @param {Mixed} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns a `lodash` instance.\n     * @example\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // returns an unwrapped value\n     * wrapped.reduce(function(sum, num) {\n     *   return sum + num;\n     * });\n     * // => 6\n     *\n     * // returns a wrapped value\n     * var squares = wrapped.map(function(num) {\n     *   return num * num;\n     * });\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      // don't wrap if already wrapped, even if wrapped by a different `lodash` constructor\n      return (value && typeof value == 'object' && !isArray(value) && hasOwnProperty.call(value, '__wrapped__'))\n       ? value\n       : new lodashWrapper(value);\n    }\n\n    /**\n     * An object used to flag environments features.\n     *\n     * @static\n     * @memberOf _\n     * @type Object\n     */\n    var support = lodash.support = {};\n\n    /**\n     * Detect if `Function#bind` exists and is inferred to be fast (all but V8).\n     *\n     * @memberOf _.support\n     * @type Boolean\n     */\n    support.fastBind = nativeBind && !isV8;\n\n    /**\n     * By default, the template delimiters used by Lo-Dash are similar to those in\n     * embedded Ruby (ERB). Change the following template settings to use alternative\n     * delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type Object\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'escape': /<%-([\\s\\S]+?)%>/g,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'evaluate': /<%([\\s\\S]+?)%>/g,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type String\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type Object\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type Function\n         */\n        '_': lodash\n      }\n    };\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Creates a function optimized to search large arrays for a given `value`,\n     * starting at `fromIndex`, using strict equality for comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {Array} array The array to search.\n     * @param {Mixed} value The value to search for.\n     * @returns {Boolean} Returns `true`, if `value` is found, else `false`.\n     */\n    function cachedContains(array) {\n      var length = array.length,\n          isLarge = length >= largeArraySize;\n\n      if (isLarge) {\n        var cache = {},\n            index = -1;\n\n        while (++index < length) {\n          var key = keyPrefix + array[index];\n          (cache[key] || (cache[key] = [])).push(array[index]);\n        }\n      }\n      return function(value) {\n        if (isLarge) {\n          var key = keyPrefix + value;\n          return  cache[key] && indexOf(cache[key], value) > -1;\n        }\n        return indexOf(array, value) > -1;\n      }\n    }\n\n    /**\n     * Used by `_.max` and `_.min` as the default `callback` when a given\n     * `collection` is a string value.\n     *\n     * @private\n     * @param {String} value The character to inspect.\n     * @returns {Number} Returns the code unit of given character.\n     */\n    function charAtCallback(value) {\n      return value.charCodeAt(0);\n    }\n\n    /**\n     * Used by `sortBy` to compare transformed `collection` values, stable sorting\n     * them in ascending order.\n     *\n     * @private\n     * @param {Object} a The object to compare to `b`.\n     * @param {Object} b The object to compare to `a`.\n     * @returns {Number} Returns the sort order indicator of `1` or `-1`.\n     */\n    function compareAscending(a, b) {\n      var ai = a.index,\n          bi = b.index;\n\n      a = a.criteria;\n      b = b.criteria;\n\n      // ensure a stable sort in V8 and other engines\n      // http://code.google.com/p/v8/issues/detail?id=90\n      if (a !== b) {\n        if (a > b || typeof a == 'undefined') {\n          return 1;\n        }\n        if (a < b || typeof b == 'undefined') {\n          return -1;\n        }\n      }\n      return ai < bi ? -1 : 1;\n    }\n\n    /**\n     * Creates a function that, when called, invokes `func` with the `this` binding\n     * of `thisArg` and prepends any `partialArgs` to the arguments passed to the\n     * bound function.\n     *\n     * @private\n     * @param {Function|String} func The function to bind or the method name.\n     * @param {Mixed} [thisArg] The `this` binding of `func`.\n     * @param {Array} partialArgs An array of arguments to be partially applied.\n     * @param {Object} [idicator] Used to indicate binding by key or partially\n     *  applying arguments from the right.\n     * @returns {Function} Returns the new bound function.\n     */\n    function createBound(func, thisArg, partialArgs, indicator) {\n      var isFunc = isFunction(func),\n          isPartial = !partialArgs,\n          key = thisArg;\n\n      // juggle arguments\n      if (isPartial) {\n        var rightIndicator = indicator;\n        partialArgs = thisArg;\n      }\n      else if (!isFunc) {\n        if (!indicator) {\n          throw new TypeError;\n        }\n        thisArg = func;\n      }\n\n      function bound() {\n        // `Function#bind` spec\n        // http://es5.github.com/#x15.3.4.5\n        var args = arguments,\n            thisBinding = isPartial ? this : thisArg;\n\n        if (!isFunc) {\n          func = thisArg[key];\n        }\n        if (partialArgs.length) {\n          args = args.length\n            ? (args = nativeSlice.call(args), rightIndicator ? args.concat(partialArgs) : partialArgs.concat(args))\n            : partialArgs;\n        }\n        if (this instanceof bound) {\n          // ensure `new bound` is an instance of `func`\n          noop.prototype = func.prototype;\n          thisBinding = new noop;\n          noop.prototype = null;\n\n          // mimic the constructor's `return` behavior\n          // http://es5.github.com/#x13.2.2\n          var result = func.apply(thisBinding, args);\n          return isObject(result) ? result : thisBinding;\n        }\n        return func.apply(thisBinding, args);\n      }\n      return bound;\n    }\n\n    /**\n     * Used by `template` to escape characters for inclusion in compiled\n     * string literals.\n     *\n     * @private\n     * @param {String} match The matched character to escape.\n     * @returns {String} Returns the escaped character.\n     */\n    function escapeStringChar(match) {\n      return '\\\\' + stringEscapes[match];\n    }\n\n    /**\n     * Used by `escape` to convert characters to HTML entities.\n     *\n     * @private\n     * @param {String} match The matched character to escape.\n     * @returns {String} Returns the escaped character.\n     */\n    function escapeHtmlChar(match) {\n      return htmlEscapes[match];\n    }\n\n    /**\n     * A fast path for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {Mixed} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns a `lodash` instance.\n     */\n    function lodashWrapper(value) {\n      this.__wrapped__ = value;\n    }\n    // ensure `new lodashWrapper` is an instance of `lodash`\n    lodashWrapper.prototype = lodash.prototype;\n\n    /**\n     * A no-operation function.\n     *\n     * @private\n     */\n    function noop() {\n      // no operation performed\n    }\n\n    /**\n     * A fallback implementation of `isPlainObject` which checks if a given `value`\n     * is an object created by the `Object` constructor, assuming objects created\n     * by the `Object` constructor have no inherited enumerable properties and that\n     * there are no `Object.prototype` extensions.\n     *\n     * @private\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.\n     */\n    function shimIsPlainObject(value) {\n      // avoid non-objects and false positives for `arguments` objects\n      var result = false;\n      if (!(value && toString.call(value) == objectClass)) {\n        return result;\n      }\n      // check that the constructor is `Object` (i.e. `Object instanceof Object`)\n      var ctor = value.constructor;\n\n      if (isFunction(ctor) ? ctor instanceof ctor : true) {\n        // In most environments an object's own properties are iterated before\n        // its inherited properties. If the last iterated property is an object's\n        // own property then there are no inherited enumerable properties.\n        forIn(value, function(value, key) {\n          result = key;\n        });\n        return result === false || hasOwnProperty.call(value, result);\n      }\n      return result;\n    }\n\n    /**\n     * Slices the `collection` from the `start` index up to, but not including,\n     * the `end` index.\n     *\n     * Note: This function is used, instead of `Array#slice`, to support node lists\n     * in IE < 9 and to ensure dense arrays are returned.\n     *\n     * @private\n     * @param {Array|Object|String} collection The collection to slice.\n     * @param {Number} start The start index.\n     * @param {Number} end The end index.\n     * @returns {Array} Returns the new array.\n     */\n    function slice(array, start, end) {\n      start || (start = 0);\n      if (typeof end == 'undefined') {\n        end = array ? array.length : 0;\n      }\n      var index = -1,\n          length = end - start || 0,\n          result = Array(length < 0 ? 0 : length);\n\n      while (++index < length) {\n        result[index] = array[start + index];\n      }\n      return result;\n    }\n\n    /**\n     * Used by `unescape` to convert HTML entities to characters.\n     *\n     * @private\n     * @param {String} match The matched character to unescape.\n     * @returns {String} Returns the unescaped character.\n     */\n    function unescapeHtmlChar(match) {\n      return htmlUnescapes[match];\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Checks if `value` is an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is an `arguments` object, else `false`.\n     * @example\n     *\n     * (function() { return _.isArguments(arguments); })(1, 2, 3);\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    function isArguments(value) {\n      return toString.call(value) == argsClass;\n    }\n\n    /**\n     * Checks if `value` is an array.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is an array, else `false`.\n     * @example\n     *\n     * (function() { return _.isArray(arguments); })();\n     * // => false\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     */\n    var isArray = nativeIsArray;\n\n    /**\n     * A fallback implementation of `Object.keys` which produces an array of the\n     * given object's own enumerable property names.\n     *\n     * @private\n     * @type Function\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns a new array of property names.\n     */\n    var shimKeys = function (object) {\n      var index, iterable = object, result = [];\n      if (!iterable) return result;\n      if (!(objectTypes[typeof object])) return result;\n\n        for (index in iterable) {\n          if (hasOwnProperty.call(iterable, index)) {    \n          result.push(index);    \n          }\n        }    \n      return result\n    };\n\n    /**\n     * Creates an array composed of the own enumerable property names of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns a new array of property names.\n     * @example\n     *\n     * _.keys({ 'one': 1, 'two': 2, 'three': 3 });\n     * // => ['one', 'two', 'three'] (order is not guaranteed)\n     */\n    var keys = !nativeKeys ? shimKeys : function(object) {\n      if (!isObject(object)) {\n        return [];\n      }\n      return nativeKeys(object);\n    };\n\n    /**\n     * Used to convert characters to HTML entities:\n     *\n     * Though the `>` character is escaped for symmetry, characters like `>` and `/`\n     * don't require escaping in HTML and have no special meaning unless they're part\n     * of a tag or an unquoted attribute value.\n     * http://mathiasbynens.be/notes/ambiguous-ampersands (under \"semi-related fun fact\")\n     */\n    var htmlEscapes = {\n      '&': '&amp;',\n      '<': '&lt;',\n      '>': '&gt;',\n      '\"': '&quot;',\n      \"'\": '&#39;'\n    };\n\n    /** Used to convert HTML entities to characters */\n    var htmlUnescapes = invert(htmlEscapes);\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Assigns own enumerable properties of source object(s) to the destination\n     * object. Subsequent sources will overwrite property assignments of previous\n     * sources. If a `callback` function is passed, it will be executed to produce\n     * the assigned values. The `callback` is bound to `thisArg` and invoked with\n     * two arguments; (objectValue, sourceValue).\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @alias extend\n     * @category Objects\n     * @param {Object} object The destination object.\n     * @param {Object} [source1, source2, ...] The source objects.\n     * @param {Function} [callback] The function to customize assigning values.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns the destination object.\n     * @example\n     *\n     * _.assign({ 'name': 'moe' }, { 'age': 40 });\n     * // => { 'name': 'moe', 'age': 40 }\n     *\n     * var defaults = _.partialRight(_.assign, function(a, b) {\n     *   return typeof a == 'undefined' ? b : a;\n     * });\n     *\n     * var food = { 'name': 'apple' };\n     * defaults(food, { 'name': 'banana', 'type': 'fruit' });\n     * // => { 'name': 'apple', 'type': 'fruit' }\n     */\n    var assign = function (object, source, guard) {\n      var index, iterable = object, result = iterable;\n      if (!iterable) return result;\n      var args = arguments,\n          argsIndex = 0,\n          argsLength = typeof guard == 'number' ? 2 : args.length;\n      if (argsLength > 3 && typeof args[argsLength - 2] == 'function') {\n        var callback = lodash.createCallback(args[--argsLength - 1], args[argsLength--], 2);\n      } else if (argsLength > 2 && typeof args[argsLength - 1] == 'function') {\n        callback = args[--argsLength];\n      }\n      while (++argsIndex < argsLength) {\n        iterable = args[argsIndex];\n        if (iterable && objectTypes[typeof iterable]) {;\n      var length = iterable.length; index = -1;\n      if (isArray(iterable)) {\n        while (++index < length) {\n          result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]\n        }\n      }\n      else {    \n        var ownIndex = -1,\n            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],\n            length = ownProps.length;\n\n        while (++ownIndex < length) {\n          index = ownProps[ownIndex];\n          result[index] = callback ? callback(result[index], iterable[index]) : iterable[index]\n        }    \n      }\n        }\n      };\n      return result\n    };\n\n    /**\n     * Creates a clone of `value`. If `deep` is `true`, nested objects will also\n     * be cloned, otherwise they will be assigned by reference. If a `callback`\n     * function is passed, it will be executed to produce the cloned values. If\n     * `callback` returns `undefined`, cloning will be handled by the method instead.\n     * The `callback` is bound to `thisArg` and invoked with one argument; (value).\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to clone.\n     * @param {Boolean} [deep=false] A flag to indicate a deep clone.\n     * @param {Function} [callback] The function to customize cloning values.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @param- {Array} [stackA=[]] Tracks traversed source objects.\n     * @param- {Array} [stackB=[]] Associates clones with source counterparts.\n     * @returns {Mixed} Returns the cloned `value`.\n     * @example\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * var shallow = _.clone(stooges);\n     * shallow[0] === stooges[0];\n     * // => true\n     *\n     * var deep = _.clone(stooges, true);\n     * deep[0] === stooges[0];\n     * // => false\n     *\n     * _.mixin({\n     *   'clone': _.partialRight(_.clone, function(value) {\n     *     return _.isElement(value) ? value.cloneNode(false) : undefined;\n     *   })\n     * });\n     *\n     * var clone = _.clone(document.body);\n     * clone.childNodes.length;\n     * // => 0\n     */\n    function clone(value, deep, callback, thisArg, stackA, stackB) {\n      var result = value;\n\n      // allows working with \"Collections\" methods without using their `callback`\n      // argument, `index|key`, for this method's `callback`\n      if (typeof deep == 'function') {\n        thisArg = callback;\n        callback = deep;\n        deep = false;\n      }\n      if (typeof callback == 'function') {\n        callback = (typeof thisArg == 'undefined')\n          ? callback\n          : lodash.createCallback(callback, thisArg, 1);\n\n        result = callback(result);\n        if (typeof result != 'undefined') {\n          return result;\n        }\n        result = value;\n      }\n      // inspect [[Class]]\n      var isObj = isObject(result);\n      if (isObj) {\n        var className = toString.call(result);\n        if (!cloneableClasses[className]) {\n          return result;\n        }\n        var isArr = isArray(result);\n      }\n      // shallow clone\n      if (!isObj || !deep) {\n        return isObj\n          ? (isArr ? slice(result) : assign({}, result))\n          : result;\n      }\n      var ctor = ctorByClass[className];\n      switch (className) {\n        case boolClass:\n        case dateClass:\n          return new ctor(+result);\n\n        case numberClass:\n        case stringClass:\n          return new ctor(result);\n\n        case regexpClass:\n          return ctor(result.source, reFlags.exec(result));\n      }\n      // check for circular references and return corresponding clone\n      stackA || (stackA = []);\n      stackB || (stackB = []);\n\n      var length = stackA.length;\n      while (length--) {\n        if (stackA[length] == value) {\n          return stackB[length];\n        }\n      }\n      // init cloned object\n      result = isArr ? ctor(result.length) : {};\n\n      // add array properties assigned by `RegExp#exec`\n      if (isArr) {\n        if (hasOwnProperty.call(value, 'index')) {\n          result.index = value.index;\n        }\n        if (hasOwnProperty.call(value, 'input')) {\n          result.input = value.input;\n        }\n      }\n      // add the source value to the stack of traversed objects\n      // and associate it with its clone\n      stackA.push(value);\n      stackB.push(result);\n\n      // recursively populate clone (susceptible to call stack limits)\n      (isArr ? forEach : forOwn)(value, function(objValue, key) {\n        result[key] = clone(objValue, deep, callback, undefined, stackA, stackB);\n      });\n\n      return result;\n    }\n\n    /**\n     * Creates a deep clone of `value`. If a `callback` function is passed,\n     * it will be executed to produce the cloned values. If `callback` returns\n     * `undefined`, cloning will be handled by the method instead. The `callback`\n     * is bound to `thisArg` and invoked with one argument; (value).\n     *\n     * Note: This function is loosely based on the structured clone algorithm. Functions\n     * and DOM nodes are **not** cloned. The enumerable properties of `arguments` objects and\n     * objects created by constructors other than `Object` are cloned to plain `Object` objects.\n     * See http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to deep clone.\n     * @param {Function} [callback] The function to customize cloning values.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the deep cloned `value`.\n     * @example\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * var deep = _.cloneDeep(stooges);\n     * deep[0] === stooges[0];\n     * // => false\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'node': element\n     * };\n     *\n     * var clone = _.cloneDeep(view, function(value) {\n     *   return _.isElement(value) ? value.cloneNode(true) : undefined;\n     * });\n     *\n     * clone.node == view.node;\n     * // => false\n     */\n    function cloneDeep(value, callback, thisArg) {\n      return clone(value, true, callback, thisArg);\n    }\n\n    /**\n     * Assigns own enumerable properties of source object(s) to the destination\n     * object for all destination properties that resolve to `undefined`. Once a\n     * property is set, additional defaults of the same property will be ignored.\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @category Objects\n     * @param {Object} object The destination object.\n     * @param {Object} [source1, source2, ...] The source objects.\n     * @param- {Object} [guard] Allows working with `_.reduce` without using its\n     *  callback's `key` and `object` arguments as sources.\n     * @returns {Object} Returns the destination object.\n     * @example\n     *\n     * var food = { 'name': 'apple' };\n     * _.defaults(food, { 'name': 'banana', 'type': 'fruit' });\n     * // => { 'name': 'apple', 'type': 'fruit' }\n     */\n    var defaults = function (object, source, guard) {\n      var index, iterable = object, result = iterable;\n      if (!iterable) return result;\n      var args = arguments,\n          argsIndex = 0,\n          argsLength = typeof guard == 'number' ? 2 : args.length;\n      while (++argsIndex < argsLength) {\n        iterable = args[argsIndex];\n        if (iterable && objectTypes[typeof iterable]) {;\n      var length = iterable.length; index = -1;\n      if (isArray(iterable)) {\n        while (++index < length) {\n          if (typeof result[index] == 'undefined') result[index] = iterable[index]\n        }\n      }\n      else {    \n        var ownIndex = -1,\n            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],\n            length = ownProps.length;\n\n        while (++ownIndex < length) {\n          index = ownProps[ownIndex];\n          if (typeof result[index] == 'undefined') result[index] = iterable[index]\n        }    \n      }\n        }\n      };\n      return result\n    };\n\n    /**\n     * This method is similar to `_.find`, except that it returns the key of the\n     * element that passes the callback check, instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to search.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the key of the found element, else `undefined`.\n     * @example\n     *\n     * _.findKey({ 'a': 1, 'b': 2, 'c': 3, 'd': 4 }, function(num) {\n     *   return num % 2 == 0;\n     * });\n     * // => 'b'\n     */\n    function findKey(object, callback, thisArg) {\n      var result;\n      callback = lodash.createCallback(callback, thisArg);\n      forOwn(object, function(value, key, object) {\n        if (callback(value, key, object)) {\n          result = key;\n          return false;\n        }\n      });\n      return result;\n    }\n\n    /**\n     * Iterates over `object`'s own and inherited enumerable properties, executing\n     * the `callback` for each property. The `callback` is bound to `thisArg` and\n     * invoked with three arguments; (value, key, object). Callbacks may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @category Objects\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [callback=identity] The function called per iteration.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function Dog(name) {\n     *   this.name = name;\n     * }\n     *\n     * Dog.prototype.bark = function() {\n     *   alert('Woof, woof!');\n     * };\n     *\n     * _.forIn(new Dog('Dagny'), function(value, key) {\n     *   alert(key);\n     * });\n     * // => alerts 'name' and 'bark' (order is not guaranteed)\n     */\n    var forIn = function (collection, callback, thisArg) {\n      var index, iterable = collection, result = iterable;\n      if (!iterable) return result;\n      if (!objectTypes[typeof iterable]) return result;\n      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);\n\n        for (index in iterable) {\n          if (callback(iterable[index], index, collection) === false) return result;    \n        }    \n      return result\n    };\n\n    /**\n     * Iterates over an object's own enumerable properties, executing the `callback`\n     * for each property. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, key, object). Callbacks may exit iteration early by explicitly\n     * returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @category Objects\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [callback=identity] The function called per iteration.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * _.forOwn({ '0': 'zero', '1': 'one', 'length': 2 }, function(num, key) {\n     *   alert(key);\n     * });\n     * // => alerts '0', '1', and 'length' (order is not guaranteed)\n     */\n    var forOwn = function (collection, callback, thisArg) {\n      var index, iterable = collection, result = iterable;\n      if (!iterable) return result;\n      if (!objectTypes[typeof iterable]) return result;\n      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);\n\n        var ownIndex = -1,\n            ownProps = objectTypes[typeof iterable] ? keys(iterable) : [],\n            length = ownProps.length;\n\n        while (++ownIndex < length) {\n          index = ownProps[ownIndex];\n          if (callback(iterable[index], index, collection) === false) return result\n        }    \n      return result\n    };\n\n    /**\n     * Creates a sorted array of all enumerable properties, own and inherited,\n     * of `object` that have function values.\n     *\n     * @static\n     * @memberOf _\n     * @alias methods\n     * @category Objects\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns a new array of property names that have function values.\n     * @example\n     *\n     * _.functions(_);\n     * // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...]\n     */\n    function functions(object) {\n      var result = [];\n      forIn(object, function(value, key) {\n        if (isFunction(value)) {\n          result.push(key);\n        }\n      });\n      return result.sort();\n    }\n\n    /**\n     * Checks if the specified object `property` exists and is a direct property,\n     * instead of an inherited property.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to check.\n     * @param {String} property The property to check for.\n     * @returns {Boolean} Returns `true` if key is a direct property, else `false`.\n     * @example\n     *\n     * _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b');\n     * // => true\n     */\n    function has(object, property) {\n      return object ? hasOwnProperty.call(object, property) : false;\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of the given `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to invert.\n     * @returns {Object} Returns the created inverted object.\n     * @example\n     *\n     *  _.invert({ 'first': 'moe', 'second': 'larry' });\n     * // => { 'moe': 'first', 'larry': 'second' }\n     */\n    function invert(object) {\n      var index = -1,\n          props = keys(object),\n          length = props.length,\n          result = {};\n\n      while (++index < length) {\n        var key = props[index];\n        result[object[key]] = key;\n      }\n      return result;\n    }\n\n    /**\n     * Checks if `value` is a boolean value.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a boolean value, else `false`.\n     * @example\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false || toString.call(value) == boolClass;\n    }\n\n    /**\n     * Checks if `value` is a date.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a date, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     */\n    function isDate(value) {\n      return value ? (typeof value == 'object' && toString.call(value) == dateClass) : false;\n    }\n\n    /**\n     * Checks if `value` is a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     */\n    function isElement(value) {\n      return value ? value.nodeType === 1 : false;\n    }\n\n    /**\n     * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a\n     * length of `0` and objects with no own enumerable properties are considered\n     * \"empty\".\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Array|Object|String} value The value to inspect.\n     * @returns {Boolean} Returns `true`, if the `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({});\n     * // => true\n     *\n     * _.isEmpty('');\n     * // => true\n     */\n    function isEmpty(value) {\n      var result = true;\n      if (!value) {\n        return result;\n      }\n      var className = toString.call(value),\n          length = value.length;\n\n      if ((className == arrayClass || className == stringClass || className == argsClass ) ||\n          (className == objectClass && typeof length == 'number' && isFunction(value.splice))) {\n        return !length;\n      }\n      forOwn(value, function() {\n        return (result = false);\n      });\n      return result;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent to each other. If `callback` is passed, it will be executed to\n     * compare values. If `callback` returns `undefined`, comparisons will be handled\n     * by the method instead. The `callback` is bound to `thisArg` and invoked with\n     * two arguments; (a, b).\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} a The value to compare.\n     * @param {Mixed} b The other value to compare.\n     * @param {Function} [callback] The function to customize comparing values.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @param- {Array} [stackA=[]] Tracks traversed `a` objects.\n     * @param- {Array} [stackB=[]] Tracks traversed `b` objects.\n     * @returns {Boolean} Returns `true`, if the values are equivalent, else `false`.\n     * @example\n     *\n     * var moe = { 'name': 'moe', 'age': 40 };\n     * var copy = { 'name': 'moe', 'age': 40 };\n     *\n     * moe == copy;\n     * // => false\n     *\n     * _.isEqual(moe, copy);\n     * // => true\n     *\n     * var words = ['hello', 'goodbye'];\n     * var otherWords = ['hi', 'goodbye'];\n     *\n     * _.isEqual(words, otherWords, function(a, b) {\n     *   var reGreet = /^(?:hello|hi)$/i,\n     *       aGreet = _.isString(a) && reGreet.test(a),\n     *       bGreet = _.isString(b) && reGreet.test(b);\n     *\n     *   return (aGreet || bGreet) ? (aGreet == bGreet) : undefined;\n     * });\n     * // => true\n     */\n    function isEqual(a, b, callback, thisArg, stackA, stackB) {\n      // used to indicate that when comparing objects, `a` has at least the properties of `b`\n      var whereIndicator = callback === indicatorObject;\n      if (typeof callback == 'function' && !whereIndicator) {\n        callback = lodash.createCallback(callback, thisArg, 2);\n        var result = callback(a, b);\n        if (typeof result != 'undefined') {\n          return !!result;\n        }\n      }\n      // exit early for identical values\n      if (a === b) {\n        // treat `+0` vs. `-0` as not equal\n        return a !== 0 || (1 / a == 1 / b);\n      }\n      var type = typeof a,\n          otherType = typeof b;\n\n      // exit early for unlike primitive values\n      if (a === a &&\n          (!a || (type != 'function' && type != 'object')) &&\n          (!b || (otherType != 'function' && otherType != 'object'))) {\n        return false;\n      }\n      // exit early for `null` and `undefined`, avoiding ES3's Function#call behavior\n      // http://es5.github.com/#x15.3.4.4\n      if (a == null || b == null) {\n        return a === b;\n      }\n      // compare [[Class]] names\n      var className = toString.call(a),\n          otherClass = toString.call(b);\n\n      if (className == argsClass) {\n        className = objectClass;\n      }\n      if (otherClass == argsClass) {\n        otherClass = objectClass;\n      }\n      if (className != otherClass) {\n        return false;\n      }\n      switch (className) {\n        case boolClass:\n        case dateClass:\n          // coerce dates and booleans to numbers, dates to milliseconds and booleans\n          // to `1` or `0`, treating invalid dates coerced to `NaN` as not equal\n          return +a == +b;\n\n        case numberClass:\n          // treat `NaN` vs. `NaN` as equal\n          return (a != +a)\n            ? b != +b\n            // but treat `+0` vs. `-0` as not equal\n            : (a == 0 ? (1 / a == 1 / b) : a == +b);\n\n        case regexpClass:\n        case stringClass:\n          // coerce regexes to strings (http://es5.github.com/#x15.10.6.4)\n          // treat string primitives and their corresponding object instances as equal\n          return a == String(b);\n      }\n      var isArr = className == arrayClass;\n      if (!isArr) {\n        // unwrap any `lodash` wrapped values\n        if (hasOwnProperty.call(a, '__wrapped__ ') || hasOwnProperty.call(b, '__wrapped__')) {\n          return isEqual(a.__wrapped__ || a, b.__wrapped__ || b, callback, thisArg, stackA, stackB);\n        }\n        // exit for functions and DOM nodes\n        if (className != objectClass) {\n          return false;\n        }\n        // in older versions of Opera, `arguments` objects have `Array` constructors\n        var ctorA = a.constructor,\n            ctorB = b.constructor;\n\n        // non `Object` object instances with different constructors are not equal\n        if (ctorA != ctorB && !(\n              isFunction(ctorA) && ctorA instanceof ctorA &&\n              isFunction(ctorB) && ctorB instanceof ctorB\n            )) {\n          return false;\n        }\n      }\n      // assume cyclic structures are equal\n      // the algorithm for detecting cyclic structures is adapted from ES 5.1\n      // section 15.12.3, abstract operation `JO` (http://es5.github.com/#x15.12.3)\n      stackA || (stackA = []);\n      stackB || (stackB = []);\n\n      var length = stackA.length;\n      while (length--) {\n        if (stackA[length] == a) {\n          return stackB[length] == b;\n        }\n      }\n      var size = 0;\n      result = true;\n\n      // add `a` and `b` to the stack of traversed objects\n      stackA.push(a);\n      stackB.push(b);\n\n      // recursively compare objects and arrays (susceptible to call stack limits)\n      if (isArr) {\n        length = a.length;\n        size = b.length;\n\n        // compare lengths to determine if a deep comparison is necessary\n        result = size == a.length;\n        if (!result && !whereIndicator) {\n          return result;\n        }\n        // deep compare the contents, ignoring non-numeric properties\n        while (size--) {\n          var index = length,\n              value = b[size];\n\n          if (whereIndicator) {\n            while (index--) {\n              if ((result = isEqual(a[index], value, callback, thisArg, stackA, stackB))) {\n                break;\n              }\n            }\n          } else if (!(result = isEqual(a[size], value, callback, thisArg, stackA, stackB))) {\n            break;\n          }\n        }\n        return result;\n      }\n      // deep compare objects using `forIn`, instead of `forOwn`, to avoid `Object.keys`\n      // which, in this case, is more costly\n      forIn(b, function(value, key, b) {\n        if (hasOwnProperty.call(b, key)) {\n          // count the number of properties.\n          size++;\n          // deep compare each property value.\n          return (result = hasOwnProperty.call(a, key) && isEqual(a[key], value, callback, thisArg, stackA, stackB));\n        }\n      });\n\n      if (result && !whereIndicator) {\n        // ensure both objects have the same number of properties\n        forIn(a, function(value, key, a) {\n          if (hasOwnProperty.call(a, key)) {\n            // `size` will be `-1` if `a` has more properties than `b`\n            return (result = --size > -1);\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Checks if `value` is, or can be coerced to, a finite number.\n     *\n     * Note: This is not the same as native `isFinite`, which will return true for\n     * booleans and empty strings. See http://es5.github.com/#x15.1.2.5.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is finite, else `false`.\n     * @example\n     *\n     * _.isFinite(-101);\n     * // => true\n     *\n     * _.isFinite('10');\n     * // => true\n     *\n     * _.isFinite(true);\n     * // => false\n     *\n     * _.isFinite('');\n     * // => false\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     */\n    function isFinite(value) {\n      return nativeIsFinite(value) && !nativeIsNaN(parseFloat(value));\n    }\n\n    /**\n     * Checks if `value` is a function.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a function, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     */\n    function isFunction(value) {\n      return typeof value == 'function';\n    }\n\n    /**\n     * Checks if `value` is the language type of Object.\n     * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(1);\n     * // => false\n     */\n    function isObject(value) {\n      // check if the value is the ECMAScript language type of Object\n      // http://es5.github.com/#x8\n      // and avoid a V8 bug\n      // http://code.google.com/p/v8/issues/detail?id=2291\n      return value ? objectTypes[typeof value] : false;\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * Note: This is not the same as native `isNaN`, which will return `true` for\n     * `undefined` and other values. See http://es5.github.com/#x15.1.2.4.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // `NaN` as a primitive is the only value that is not equal to itself\n      // (perform the [[Class]] check first to avoid errors with some host objects in IE)\n      return isNumber(value) && value != +value\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(undefined);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is a number.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a number, else `false`.\n     * @example\n     *\n     * _.isNumber(8.4 * 5);\n     * // => true\n     */\n    function isNumber(value) {\n      return typeof value == 'number' || toString.call(value) == numberClass;\n    }\n\n    /**\n     * Checks if a given `value` is an object created by the `Object` constructor.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Stooge(name, age) {\n     *   this.name = name;\n     *   this.age = age;\n     * }\n     *\n     * _.isPlainObject(new Stooge('moe', 40));\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'name': 'moe', 'age': 40 });\n     * // => true\n     */\n    var isPlainObject = function(value) {\n      if (!(value && toString.call(value) == objectClass)) {\n        return false;\n      }\n      var valueOf = value.valueOf,\n          objProto = typeof valueOf == 'function' && (objProto = getPrototypeOf(valueOf)) && getPrototypeOf(objProto);\n\n      return objProto\n        ? (value == objProto || getPrototypeOf(value) == objProto)\n        : shimIsPlainObject(value);\n    };\n\n    /**\n     * Checks if `value` is a regular expression.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a regular expression, else `false`.\n     * @example\n     *\n     * _.isRegExp(/moe/);\n     * // => true\n     */\n    function isRegExp(value) {\n      return value ? (typeof value == 'object' && toString.call(value) == regexpClass) : false;\n    }\n\n    /**\n     * Checks if `value` is a string.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is a string, else `false`.\n     * @example\n     *\n     * _.isString('moe');\n     * // => true\n     */\n    function isString(value) {\n      return typeof value == 'string' || toString.call(value) == stringClass;\n    }\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Mixed} value The value to check.\n     * @returns {Boolean} Returns `true`, if the `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     */\n    function isUndefined(value) {\n      return typeof value == 'undefined';\n    }\n\n    /**\n     * Recursively merges own enumerable properties of the source object(s), that\n     * don't resolve to `undefined`, into the destination object. Subsequent sources\n     * will overwrite property assignments of previous sources. If a `callback` function\n     * is passed, it will be executed to produce the merged values of the destination\n     * and source properties. If `callback` returns `undefined`, merging will be\n     * handled by the method instead. The `callback` is bound to `thisArg` and\n     * invoked with two arguments; (objectValue, sourceValue).\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The destination object.\n     * @param {Object} [source1, source2, ...] The source objects.\n     * @param {Function} [callback] The function to customize merging properties.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @param- {Object} [deepIndicator] Indicates that `stackA` and `stackB` are\n     *  arrays of traversed objects, instead of source objects.\n     * @param- {Array} [stackA=[]] Tracks traversed source objects.\n     * @param- {Array} [stackB=[]] Associates values with source counterparts.\n     * @returns {Object} Returns the destination object.\n     * @example\n     *\n     * var names = {\n     *   'stooges': [\n     *     { 'name': 'moe' },\n     *     { 'name': 'larry' }\n     *   ]\n     * };\n     *\n     * var ages = {\n     *   'stooges': [\n     *     { 'age': 40 },\n     *     { 'age': 50 }\n     *   ]\n     * };\n     *\n     * _.merge(names, ages);\n     * // => { 'stooges': [{ 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }] }\n     *\n     * var food = {\n     *   'fruits': ['apple'],\n     *   'vegetables': ['beet']\n     * };\n     *\n     * var otherFood = {\n     *   'fruits': ['banana'],\n     *   'vegetables': ['carrot']\n     * };\n     *\n     * _.merge(food, otherFood, function(a, b) {\n     *   return _.isArray(a) ? a.concat(b) : undefined;\n     * });\n     * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot] }\n     */\n    function merge(object, source, deepIndicator) {\n      var args = arguments,\n          index = 0,\n          length = 2;\n\n      if (!isObject(object)) {\n        return object;\n      }\n      if (deepIndicator === indicatorObject) {\n        var callback = args[3],\n            stackA = args[4],\n            stackB = args[5];\n      } else {\n        stackA = [];\n        stackB = [];\n\n        // allows working with `_.reduce` and `_.reduceRight` without\n        // using their `callback` arguments, `index|key` and `collection`\n        if (typeof deepIndicator != 'number') {\n          length = args.length;\n        }\n        if (length > 3 && typeof args[length - 2] == 'function') {\n          callback = lodash.createCallback(args[--length - 1], args[length--], 2);\n        } else if (length > 2 && typeof args[length - 1] == 'function') {\n          callback = args[--length];\n        }\n      }\n      while (++index < length) {\n        (isArray(args[index]) ? forEach : forOwn)(args[index], function(source, key) {\n          var found,\n              isArr,\n              result = source,\n              value = object[key];\n\n          if (source && ((isArr = isArray(source)) || isPlainObject(source))) {\n            // avoid merging previously merged cyclic sources\n            var stackLength = stackA.length;\n            while (stackLength--) {\n              if ((found = stackA[stackLength] == source)) {\n                value = stackB[stackLength];\n                break;\n              }\n            }\n            if (!found) {\n              var isShallow;\n              if (callback) {\n                result = callback(value, source);\n                if ((isShallow = typeof result != 'undefined')) {\n                  value = result;\n                }\n              }\n              if (!isShallow) {\n                value = isArr\n                  ? (isArray(value) ? value : [])\n                  : (isPlainObject(value) ? value : {});\n              }\n              // add `source` and associated `value` to the stack of traversed objects\n              stackA.push(source);\n              stackB.push(value);\n\n              // recursively merge objects and arrays (susceptible to call stack limits)\n              if (!isShallow) {\n                value = merge(value, source, indicatorObject, callback, stackA, stackB);\n              }\n            }\n          }\n          else {\n            if (callback) {\n              result = callback(value, source);\n              if (typeof result == 'undefined') {\n                result = source;\n              }\n            }\n            if (typeof result != 'undefined') {\n              value = result;\n            }\n          }\n          object[key] = value;\n        });\n      }\n      return object;\n    }\n\n    /**\n     * Creates a shallow clone of `object` excluding the specified properties.\n     * Property names may be specified as individual arguments or as arrays of\n     * property names. If a `callback` function is passed, it will be executed\n     * for each property in the `object`, omitting the properties `callback`\n     * returns truthy for. The `callback` is bound to `thisArg` and invoked\n     * with three arguments; (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The source object.\n     * @param {Function|String} callback|[prop1, prop2, ...] The properties to omit\n     *  or the function called per iteration.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns an object without the omitted properties.\n     * @example\n     *\n     * _.omit({ 'name': 'moe', 'age': 40 }, 'age');\n     * // => { 'name': 'moe' }\n     *\n     * _.omit({ 'name': 'moe', 'age': 40 }, function(value) {\n     *   return typeof value == 'number';\n     * });\n     * // => { 'name': 'moe' }\n     */\n    function omit(object, callback, thisArg) {\n      var isFunc = typeof callback == 'function',\n          result = {};\n\n      if (isFunc) {\n        callback = lodash.createCallback(callback, thisArg);\n      } else {\n        var props = concat.apply(arrayRef, nativeSlice.call(arguments, 1));\n      }\n      forIn(object, function(value, key, object) {\n        if (isFunc\n              ? !callback(value, key, object)\n              : indexOf(props, key) < 0\n            ) {\n          result[key] = value;\n        }\n      });\n      return result;\n    }\n\n    /**\n     * Creates a two dimensional array of the given object's key-value pairs,\n     * i.e. `[[key1, value1], [key2, value2]]`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns new array of key-value pairs.\n     * @example\n     *\n     * _.pairs({ 'moe': 30, 'larry': 40 });\n     * // => [['moe', 30], ['larry', 40]] (order is not guaranteed)\n     */\n    function pairs(object) {\n      var index = -1,\n          props = keys(object),\n          length = props.length,\n          result = Array(length);\n\n      while (++index < length) {\n        var key = props[index];\n        result[index] = [key, object[key]];\n      }\n      return result;\n    }\n\n    /**\n     * Creates a shallow clone of `object` composed of the specified properties.\n     * Property names may be specified as individual arguments or as arrays of property\n     * names. If `callback` is passed, it will be executed for each property in the\n     * `object`, picking the properties `callback` returns truthy for. The `callback`\n     * is bound to `thisArg` and invoked with three arguments; (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The source object.\n     * @param {Array|Function|String} callback|[prop1, prop2, ...] The function called\n     *  per iteration or properties to pick, either as individual arguments or arrays.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns an object composed of the picked properties.\n     * @example\n     *\n     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, 'name');\n     * // => { 'name': 'moe' }\n     *\n     * _.pick({ 'name': 'moe', '_userid': 'moe1' }, function(value, key) {\n     *   return key.charAt(0) != '_';\n     * });\n     * // => { 'name': 'moe' }\n     */\n    function pick(object, callback, thisArg) {\n      var result = {};\n      if (typeof callback != 'function') {\n        var index = -1,\n            props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),\n            length = isObject(object) ? props.length : 0;\n\n        while (++index < length) {\n          var key = props[index];\n          if (key in object) {\n            result[key] = object[key];\n          }\n        }\n      } else {\n        callback = lodash.createCallback(callback, thisArg);\n        forIn(object, function(value, key, object) {\n          if (callback(value, key, object)) {\n            result[key] = value;\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array composed of the own enumerable property values of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Objects\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns a new array of property values.\n     * @example\n     *\n     * _.values({ 'one': 1, 'two': 2, 'three': 3 });\n     * // => [1, 2, 3] (order is not guaranteed)\n     */\n    function values(object) {\n      var index = -1,\n          props = keys(object),\n          length = props.length,\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = object[props[index]];\n      }\n      return result;\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements from the specified indexes, or keys, of the\n     * `collection`. Indexes may be specified as individual arguments or as arrays\n     * of indexes.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Array|Number|String} [index1, index2, ...] The indexes of\n     *  `collection` to retrieve, either as individual arguments or arrays.\n     * @returns {Array} Returns a new array of elements corresponding to the\n     *  provided indexes.\n     * @example\n     *\n     * _.at(['a', 'b', 'c', 'd', 'e'], [0, 2, 4]);\n     * // => ['a', 'c', 'e']\n     *\n     * _.at(['moe', 'larry', 'curly'], 0, 2);\n     * // => ['moe', 'curly']\n     */\n    function at(collection) {\n      var index = -1,\n          props = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),\n          length = props.length,\n          result = Array(length);\n\n      while(++index < length) {\n        result[index] = collection[props[index]];\n      }\n      return result;\n    }\n\n    /**\n     * Checks if a given `target` element is present in a `collection` using strict\n     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used\n     * as the offset from the end of the collection.\n     *\n     * @static\n     * @memberOf _\n     * @alias include\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Mixed} target The value to check for.\n     * @param {Number} [fromIndex=0] The index to search from.\n     * @returns {Boolean} Returns `true` if the `target` element is found, else `false`.\n     * @example\n     *\n     * _.contains([1, 2, 3], 1);\n     * // => true\n     *\n     * _.contains([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.contains({ 'name': 'moe', 'age': 40 }, 'moe');\n     * // => true\n     *\n     * _.contains('curly', 'ur');\n     * // => true\n     */\n    function contains(collection, target, fromIndex) {\n      var index = -1,\n          length = collection ? collection.length : 0,\n          result = false;\n\n      fromIndex = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex) || 0;\n      if (typeof length == 'number') {\n        result = (isString(collection)\n          ? collection.indexOf(target, fromIndex)\n          : indexOf(collection, target, fromIndex)\n        ) > -1;\n      } else {\n        forOwn(collection, function(value) {\n          if (++index >= fromIndex) {\n            return !(result = value === target);\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Creates an object composed of keys returned from running each element of the\n     * `collection` through the given `callback`. The corresponding value of each key\n     * is the number of times the key was returned by the `callback`. The `callback`\n     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([4.3, 6.1, 6.4], function(num) { return Math.floor(num); });\n     * // => { '4': 1, '6': 2 }\n     *\n     * _.countBy([4.3, 6.1, 6.4], function(num) { return this.floor(num); }, Math);\n     * // => { '4': 1, '6': 2 }\n     *\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    function countBy(collection, callback, thisArg) {\n      var result = {};\n      callback = lodash.createCallback(callback, thisArg);\n\n      forEach(collection, function(value, key, collection) {\n        key = String(callback(value, key, collection));\n        (hasOwnProperty.call(result, key) ? result[key]++ : result[key] = 1);\n      });\n      return result;\n    }\n\n    /**\n     * Checks if the `callback` returns a truthy value for **all** elements of a\n     * `collection`. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias all\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Boolean} Returns `true` if all elements pass the callback check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.every(stooges, 'age');\n     * // => true\n     *\n     * // using \"_.where\" callback shorthand\n     * _.every(stooges, { 'age': 50 });\n     * // => false\n     */\n    function every(collection, callback, thisArg) {\n      var result = true;\n      callback = lodash.createCallback(callback, thisArg);\n\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      if (typeof length == 'number') {\n        while (++index < length) {\n          if (!(result = !!callback(collection[index], index, collection))) {\n            break;\n          }\n        }\n      } else {\n        forOwn(collection, function(value, index, collection) {\n          return (result = !!callback(value, index, collection));\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Examines each element in a `collection`, returning an array of all elements\n     * the `callback` returns truthy for. The `callback` is bound to `thisArg` and\n     * invoked with three arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias select\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new array of elements that passed the callback check.\n     * @example\n     *\n     * var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });\n     * // => [2, 4, 6]\n     *\n     * var food = [\n     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },\n     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.filter(food, 'organic');\n     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]\n     *\n     * // using \"_.where\" callback shorthand\n     * _.filter(food, { 'type': 'fruit' });\n     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]\n     */\n    function filter(collection, callback, thisArg) {\n      var result = [];\n      callback = lodash.createCallback(callback, thisArg);\n\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      if (typeof length == 'number') {\n        while (++index < length) {\n          var value = collection[index];\n          if (callback(value, index, collection)) {\n            result.push(value);\n          }\n        }\n      } else {\n        forOwn(collection, function(value, index, collection) {\n          if (callback(value, index, collection)) {\n            result.push(value);\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Examines each element in a `collection`, returning the first that the `callback`\n     * returns truthy for. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias detect\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the found element, else `undefined`.\n     * @example\n     *\n     * _.find([1, 2, 3, 4], function(num) {\n     *   return num % 2 == 0;\n     * });\n     * // => 2\n     *\n     * var food = [\n     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },\n     *   { 'name': 'banana', 'organic': true,  'type': 'fruit' },\n     *   { 'name': 'beet',   'organic': false, 'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.where\" callback shorthand\n     * _.find(food, { 'type': 'vegetable' });\n     * // => { 'name': 'beet', 'organic': false, 'type': 'vegetable' }\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.find(food, 'organic');\n     * // => { 'name': 'banana', 'organic': true, 'type': 'fruit' }\n     */\n    function find(collection, callback, thisArg) {\n      callback = lodash.createCallback(callback, thisArg);\n\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      if (typeof length == 'number') {\n        while (++index < length) {\n          var value = collection[index];\n          if (callback(value, index, collection)) {\n            return value;\n          }\n        }\n      } else {\n        var result;\n        forOwn(collection, function(value, index, collection) {\n          if (callback(value, index, collection)) {\n            result = value;\n            return false;\n          }\n        });\n        return result;\n      }\n    }\n\n    /**\n     * Iterates over a `collection`, executing the `callback` for each element in\n     * the `collection`. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index|key, collection). Callbacks may exit iteration early\n     * by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias each\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function} [callback=identity] The function called per iteration.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array|Object|String} Returns `collection`.\n     * @example\n     *\n     * _([1, 2, 3]).forEach(alert).join(',');\n     * // => alerts each number and returns '1,2,3'\n     *\n     * _.forEach({ 'one': 1, 'two': 2, 'three': 3 }, alert);\n     * // => alerts each number value (order is not guaranteed)\n     */\n    function forEach(collection, callback, thisArg) {\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      callback = callback && typeof thisArg == 'undefined' ? callback : lodash.createCallback(callback, thisArg);\n      if (typeof length == 'number') {\n        while (++index < length) {\n          if (callback(collection[index], index, collection) === false) {\n            break;\n          }\n        }\n      } else {\n        forOwn(collection, callback);\n      }\n      return collection;\n    }\n\n    /**\n     * Creates an object composed of keys returned from running each element of the\n     * `collection` through the `callback`. The corresponding value of each key is\n     * an array of elements passed to `callback` that returned the key. The `callback`\n     * is bound to `thisArg` and invoked with three arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([4.2, 6.1, 6.4], function(num) { return Math.floor(num); });\n     * // => { '4': [4.2], '6': [6.1, 6.4] }\n     *\n     * _.groupBy([4.2, 6.1, 6.4], function(num) { return this.floor(num); }, Math);\n     * // => { '4': [4.2], '6': [6.1, 6.4] }\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    function groupBy(collection, callback, thisArg) {\n      var result = {};\n      callback = lodash.createCallback(callback, thisArg);\n\n      forEach(collection, function(value, key, collection) {\n        key = String(callback(value, key, collection));\n        (hasOwnProperty.call(result, key) ? result[key] : result[key] = []).push(value);\n      });\n      return result;\n    }\n\n    /**\n     * Invokes the method named by `methodName` on each element in the `collection`,\n     * returning an array of the results of each invoked method. Additional arguments\n     * will be passed to each invoked method. If `methodName` is a function, it will\n     * be invoked for, and `this` bound to, each element in the `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|String} methodName The name of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.\n     * @returns {Array} Returns a new array of the results of each invoked method.\n     * @example\n     *\n     * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invoke([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    function invoke(collection, methodName) {\n      var args = nativeSlice.call(arguments, 2),\n          index = -1,\n          isFunc = typeof methodName == 'function',\n          length = collection ? collection.length : 0,\n          result = Array(typeof length == 'number' ? length : 0);\n\n      forEach(collection, function(value) {\n        result[++index] = (isFunc ? methodName : value[methodName]).apply(value, args);\n      });\n      return result;\n    }\n\n    /**\n     * Creates an array of values by running each element in the `collection`\n     * through the `callback`. The `callback` is bound to `thisArg` and invoked with\n     * three arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias collect\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new array of the results of each `callback` execution.\n     * @example\n     *\n     * _.map([1, 2, 3], function(num) { return num * 3; });\n     * // => [3, 6, 9]\n     *\n     * _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; });\n     * // => [3, 6, 9] (order is not guaranteed)\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.map(stooges, 'name');\n     * // => ['moe', 'larry']\n     */\n    function map(collection, callback, thisArg) {\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      callback = lodash.createCallback(callback, thisArg);\n      if (typeof length == 'number') {\n        var result = Array(length);\n        while (++index < length) {\n          result[index] = callback(collection[index], index, collection);\n        }\n      } else {\n        result = [];\n        forOwn(collection, function(value, key, collection) {\n          result[++index] = callback(value, key, collection);\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Retrieves the maximum value of an `array`. If `callback` is passed,\n     * it will be executed for each value in the `array` to generate the\n     * criterion by which the value is ranked. The `callback` is bound to\n     * `thisArg` and invoked with three arguments; (value, index, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * _.max(stooges, function(stooge) { return stooge.age; });\n     * // => { 'name': 'larry', 'age': 50 };\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.max(stooges, 'age');\n     * // => { 'name': 'larry', 'age': 50 };\n     */\n    function max(collection, callback, thisArg) {\n      var computed = -Infinity,\n          result = computed;\n\n      if (!callback && isArray(collection)) {\n        var index = -1,\n            length = collection.length;\n\n        while (++index < length) {\n          var value = collection[index];\n          if (value > result) {\n            result = value;\n          }\n        }\n      } else {\n        callback = (!callback && isString(collection))\n          ? charAtCallback\n          : lodash.createCallback(callback, thisArg);\n\n        forEach(collection, function(value, index, collection) {\n          var current = callback(value, index, collection);\n          if (current > computed) {\n            computed = current;\n            result = value;\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Retrieves the minimum value of an `array`. If `callback` is passed,\n     * it will be executed for each value in the `array` to generate the\n     * criterion by which the value is ranked. The `callback` is bound to `thisArg`\n     * and invoked with three arguments; (value, index, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * _.min(stooges, function(stooge) { return stooge.age; });\n     * // => { 'name': 'moe', 'age': 40 };\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.min(stooges, 'age');\n     * // => { 'name': 'moe', 'age': 40 };\n     */\n    function min(collection, callback, thisArg) {\n      var computed = Infinity,\n          result = computed;\n\n      if (!callback && isArray(collection)) {\n        var index = -1,\n            length = collection.length;\n\n        while (++index < length) {\n          var value = collection[index];\n          if (value < result) {\n            result = value;\n          }\n        }\n      } else {\n        callback = (!callback && isString(collection))\n          ? charAtCallback\n          : lodash.createCallback(callback, thisArg);\n\n        forEach(collection, function(value, index, collection) {\n          var current = callback(value, index, collection);\n          if (current < computed) {\n            computed = current;\n            result = value;\n          }\n        });\n      }\n      return result;\n    }\n\n    /**\n     * Retrieves the value of a specified property from all elements in the `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {String} property The property to pluck.\n     * @returns {Array} Returns a new array of property values.\n     * @example\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * _.pluck(stooges, 'name');\n     * // => ['moe', 'larry']\n     */\n    function pluck(collection, property) {\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      if (typeof length == 'number') {\n        var result = Array(length);\n        while (++index < length) {\n          result[index] = collection[index][property];\n        }\n      }\n      return result || map(collection, property);\n    }\n\n    /**\n     * Reduces a `collection` to a value which is the accumulated result of running\n     * each element in the `collection` through the `callback`, where each successive\n     * `callback` execution consumes the return value of the previous execution.\n     * If `accumulator` is not passed, the first element of the `collection` will be\n     * used as the initial `accumulator` value. The `callback` is bound to `thisArg`\n     * and invoked with four arguments; (accumulator, value, index|key, collection).\n     *\n     * @static\n     * @memberOf _\n     * @alias foldl, inject\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function} [callback=identity] The function called per iteration.\n     * @param {Mixed} [accumulator] Initial value of the accumulator.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the accumulated value.\n     * @example\n     *\n     * var sum = _.reduce([1, 2, 3], function(sum, num) {\n     *   return sum + num;\n     * });\n     * // => 6\n     *\n     * var mapped = _.reduce({ 'a': 1, 'b': 2, 'c': 3 }, function(result, num, key) {\n     *   result[key] = num * 3;\n     *   return result;\n     * }, {});\n     * // => { 'a': 3, 'b': 6, 'c': 9 }\n     */\n    function reduce(collection, callback, accumulator, thisArg) {\n      if (!collection) return accumulator;\n      var noaccum = arguments.length < 3;\n      callback = lodash.createCallback(callback, thisArg, 4);\n\n      var index = -1,\n          length = collection.length;\n\n      if (typeof length == 'number') {\n        if (noaccum) {\n          accumulator = collection[++index];\n        }\n        while (++index < length) {\n          accumulator = callback(accumulator, collection[index], index, collection);\n        }\n      } else {\n        forOwn(collection, function(value, index, collection) {\n          accumulator = noaccum\n            ? (noaccum = false, value)\n            : callback(accumulator, value, index, collection)\n        });\n      }\n      return accumulator;\n    }\n\n    /**\n     * This method is similar to `_.reduce`, except that it iterates over a\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @alias foldr\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function} [callback=identity] The function called per iteration.\n     * @param {Mixed} [accumulator] Initial value of the accumulator.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the accumulated value.\n     * @example\n     *\n     * var list = [[0, 1], [2, 3], [4, 5]];\n     * var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    function reduceRight(collection, callback, accumulator, thisArg) {\n      var iterable = collection,\n          length = collection ? collection.length : 0,\n          noaccum = arguments.length < 3;\n\n      if (typeof length != 'number') {\n        var props = keys(collection);\n        length = props.length;\n      }\n      callback = lodash.createCallback(callback, thisArg, 4);\n      forEach(collection, function(value, index, collection) {\n        index = props ? props[--length] : --length;\n        accumulator = noaccum\n          ? (noaccum = false, iterable[index])\n          : callback(accumulator, iterable[index], index, collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The opposite of `_.filter`, this method returns the elements of a\n     * `collection` that `callback` does **not** return truthy for.\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new array of elements that did **not** pass the\n     *  callback check.\n     * @example\n     *\n     * var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; });\n     * // => [1, 3, 5]\n     *\n     * var food = [\n     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },\n     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.reject(food, 'organic');\n     * // => [{ 'name': 'apple', 'organic': false, 'type': 'fruit' }]\n     *\n     * // using \"_.where\" callback shorthand\n     * _.reject(food, { 'type': 'fruit' });\n     * // => [{ 'name': 'carrot', 'organic': true, 'type': 'vegetable' }]\n     */\n    function reject(collection, callback, thisArg) {\n      callback = lodash.createCallback(callback, thisArg);\n      return filter(collection, function(value, index, collection) {\n        return !callback(value, index, collection);\n      });\n    }\n\n    /**\n     * Creates an array of shuffled `array` values, using a version of the\n     * Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to shuffle.\n     * @returns {Array} Returns a new shuffled collection.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4, 5, 6]);\n     * // => [4, 1, 6, 3, 5, 2]\n     */\n    function shuffle(collection) {\n      var index = -1,\n          length = collection ? collection.length : 0,\n          result = Array(typeof length == 'number' ? length : 0);\n\n      forEach(collection, function(value) {\n        var rand = floor(nativeRandom() * (++index + 1));\n        result[index] = result[rand];\n        result[rand] = value;\n      });\n      return result;\n    }\n\n    /**\n     * Gets the size of the `collection` by returning `collection.length` for arrays\n     * and array-like objects or the number of own enumerable properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to inspect.\n     * @returns {Number} Returns `collection.length` or number of own enumerable properties.\n     * @example\n     *\n     * _.size([1, 2]);\n     * // => 2\n     *\n     * _.size({ 'one': 1, 'two': 2, 'three': 3 });\n     * // => 3\n     *\n     * _.size('curly');\n     * // => 5\n     */\n    function size(collection) {\n      var length = collection ? collection.length : 0;\n      return typeof length == 'number' ? length : keys(collection).length;\n    }\n\n    /**\n     * Checks if the `callback` returns a truthy value for **any** element of a\n     * `collection`. The function returns as soon as it finds passing value, and\n     * does not iterate over the entire `collection`. The `callback` is bound to\n     * `thisArg` and invoked with three arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias any\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Boolean} Returns `true` if any element passes the callback check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var food = [\n     *   { 'name': 'apple',  'organic': false, 'type': 'fruit' },\n     *   { 'name': 'carrot', 'organic': true,  'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.some(food, 'organic');\n     * // => true\n     *\n     * // using \"_.where\" callback shorthand\n     * _.some(food, { 'type': 'meat' });\n     * // => false\n     */\n    function some(collection, callback, thisArg) {\n      var result;\n      callback = lodash.createCallback(callback, thisArg);\n\n      var index = -1,\n          length = collection ? collection.length : 0;\n\n      if (typeof length == 'number') {\n        while (++index < length) {\n          if ((result = callback(collection[index], index, collection))) {\n            break;\n          }\n        }\n      } else {\n        forOwn(collection, function(value, index, collection) {\n          return !(result = callback(value, index, collection));\n        });\n      }\n      return !!result;\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in the `collection` through the `callback`. This method\n     * performs a stable sort, that is, it will preserve the original sort order of\n     * equal elements. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index|key, collection).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new array of sorted elements.\n     * @example\n     *\n     * _.sortBy([1, 2, 3], function(num) { return Math.sin(num); });\n     * // => [3, 1, 2]\n     *\n     * _.sortBy([1, 2, 3], function(num) { return this.sin(num); }, Math);\n     * // => [3, 1, 2]\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.sortBy(['banana', 'strawberry', 'apple'], 'length');\n     * // => ['apple', 'banana', 'strawberry']\n     */\n    function sortBy(collection, callback, thisArg) {\n      var index = -1,\n          length = collection ? collection.length : 0,\n          result = Array(typeof length == 'number' ? length : 0);\n\n      callback = lodash.createCallback(callback, thisArg);\n      forEach(collection, function(value, key, collection) {\n        result[++index] = {\n          'criteria': callback(value, key, collection),\n          'index': index,\n          'value': value\n        };\n      });\n\n      length = result.length;\n      result.sort(compareAscending);\n      while (length--) {\n        result[length] = result[length].value;\n      }\n      return result;\n    }\n\n    /**\n     * Converts the `collection` to an array.\n     *\n     * @static\n     * @memberOf _\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to convert.\n     * @returns {Array} Returns the new converted array.\n     * @example\n     *\n     * (function() { return _.toArray(arguments).slice(1); })(1, 2, 3, 4);\n     * // => [2, 3, 4]\n     */\n    function toArray(collection) {\n      if (collection && typeof collection.length == 'number') {\n        return slice(collection);\n      }\n      return values(collection);\n    }\n\n    /**\n     * Examines each element in a `collection`, returning an array of all elements\n     * that have the given `properties`. When checking `properties`, this method\n     * performs a deep comparison between values to determine if they are equivalent\n     * to each other.\n     *\n     * @static\n     * @memberOf _\n     * @type Function\n     * @category Collections\n     * @param {Array|Object|String} collection The collection to iterate over.\n     * @param {Object} properties The object of property values to filter by.\n     * @returns {Array} Returns a new array of elements that have the given `properties`.\n     * @example\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * _.where(stooges, { 'age': 40 });\n     * // => [{ 'name': 'moe', 'age': 40 }]\n     */\n    var where = filter;\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array with all falsey values of `array` removed. The values\n     * `false`, `null`, `0`, `\"\"`, `undefined` and `NaN` are all falsey.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns a new filtered array.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array ? array.length : 0,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of `array` elements not present in the other arrays\n     * using strict equality for comparisons, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to process.\n     * @param {Array} [array1, array2, ...] Arrays to check.\n     * @returns {Array} Returns a new array of `array` elements not present in the\n     *  other arrays.\n     * @example\n     *\n     * _.difference([1, 2, 3, 4, 5], [5, 2, 10]);\n     * // => [1, 3, 4]\n     */\n    function difference(array) {\n      var index = -1,\n          length = array ? array.length : 0,\n          flattened = concat.apply(arrayRef, nativeSlice.call(arguments, 1)),\n          contains = cachedContains(flattened),\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (!contains(value)) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * This method is similar to `_.find`, except that it returns the index of\n     * the element that passes the callback check, instead of the element itself.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to search.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * _.findIndex(['apple', 'banana', 'beet'], function(food) {\n     *   return /^b/.test(food);\n     * });\n     * // => 1\n     */\n    function findIndex(array, callback, thisArg) {\n      var index = -1,\n          length = array ? array.length : 0;\n\n      callback = lodash.createCallback(callback, thisArg);\n      while (++index < length) {\n        if (callback(array[index], index, array)) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Gets the first element of the `array`. If a number `n` is passed, the first\n     * `n` elements of the `array` are returned. If a `callback` function is passed,\n     * elements at the beginning of the array are returned as long as the `callback`\n     * returns truthy. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index, array).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias head, take\n     * @category Arrays\n     * @param {Array} array The array to query.\n     * @param {Function|Object|Number|String} [callback|n] The function called\n     *  per element or the number of elements to return. If a property name or\n     *  object is passed, it will be used to create a \"_.pluck\" or \"_.where\"\n     *  style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the first element(s) of `array`.\n     * @example\n     *\n     * _.first([1, 2, 3]);\n     * // => 1\n     *\n     * _.first([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.first([1, 2, 3], function(num) {\n     *   return num < 3;\n     * });\n     * // => [1, 2]\n     *\n     * var food = [\n     *   { 'name': 'banana', 'organic': true },\n     *   { 'name': 'beet',   'organic': false },\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.first(food, 'organic');\n     * // => [{ 'name': 'banana', 'organic': true }]\n     *\n     * var food = [\n     *   { 'name': 'apple',  'type': 'fruit' },\n     *   { 'name': 'banana', 'type': 'fruit' },\n     *   { 'name': 'beet',   'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.where\" callback shorthand\n     * _.first(food, { 'type': 'fruit' });\n     * // => [{ 'name': 'apple', 'type': 'fruit' }, { 'name': 'banana', 'type': 'fruit' }]\n     */\n    function first(array, callback, thisArg) {\n      if (array) {\n        var n = 0,\n            length = array.length;\n\n        if (typeof callback != 'number' && callback != null) {\n          var index = -1;\n          callback = lodash.createCallback(callback, thisArg);\n          while (++index < length && callback(array[index], index, array)) {\n            n++;\n          }\n        } else {\n          n = callback;\n          if (n == null || thisArg) {\n            return array[0];\n          }\n        }\n        return slice(array, 0, nativeMin(nativeMax(0, n), length));\n      }\n    }\n\n    /**\n     * Flattens a nested array (the nesting can be to any depth). If `isShallow`\n     * is truthy, `array` will only be flattened a single level. If `callback`\n     * is passed, each element of `array` is passed through a `callback` before\n     * flattening. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index, array).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to flatten.\n     * @param {Boolean} [isShallow=false] A flag to indicate only flattening a single level.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2], [3, [[4]]]]);\n     * // => [1, 2, 3, 4];\n     *\n     * _.flatten([1, [2], [3, [[4]]]], true);\n     * // => [1, 2, 3, [[4]]];\n     *\n     * var stooges = [\n     *   { 'name': 'curly', 'quotes': ['Oh, a wise guy, eh?', 'Poifect!'] },\n     *   { 'name': 'moe', 'quotes': ['Spread out!', 'You knucklehead!'] }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.flatten(stooges, 'quotes');\n     * // => ['Oh, a wise guy, eh?', 'Poifect!', 'Spread out!', 'You knucklehead!']\n     */\n    function flatten(array, isShallow, callback, thisArg) {\n      var index = -1,\n          length = array ? array.length : 0,\n          result = [];\n\n      // juggle arguments\n      if (typeof isShallow != 'boolean' && isShallow != null) {\n        thisArg = callback;\n        callback = isShallow;\n        isShallow = false;\n      }\n      if (callback != null) {\n        callback = lodash.createCallback(callback, thisArg);\n      }\n      while (++index < length) {\n        var value = array[index];\n        if (callback) {\n          value = callback(value, index, array);\n        }\n        // recursively flatten arrays (susceptible to call stack limits)\n        if (isArray(value)) {\n          push.apply(result, isShallow ? value : flatten(value));\n        } else {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found using\n     * strict equality for comparisons, i.e. `===`. If the `array` is already\n     * sorted, passing `true` for `fromIndex` will run a faster binary search.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to search.\n     * @param {Mixed} value The value to search for.\n     * @param {Boolean|Number} [fromIndex=0] The index to search from or `true` to\n     *  perform a binary search on a sorted `array`.\n     * @returns {Number} Returns the index of the matched value or `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 3, 1, 2, 3], 2);\n     * // => 1\n     *\n     * _.indexOf([1, 2, 3, 1, 2, 3], 2, 3);\n     * // => 4\n     *\n     * _.indexOf([1, 1, 2, 2, 3, 3], 2, true);\n     * // => 2\n     */\n    function indexOf(array, value, fromIndex) {\n      var index = -1,\n          length = array ? array.length : 0;\n\n      if (typeof fromIndex == 'number') {\n        index = (fromIndex < 0 ? nativeMax(0, length + fromIndex) : fromIndex || 0) - 1;\n      } else if (fromIndex) {\n        index = sortedIndex(array, value);\n        return array[index] === value ? index : -1;\n      }\n      while (++index < length) {\n        if (array[index] === value) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Gets all but the last element of `array`. If a number `n` is passed, the\n     * last `n` elements are excluded from the result. If a `callback` function\n     * is passed, elements at the end of the array are excluded from the result\n     * as long as the `callback` returns truthy. The `callback` is bound to\n     * `thisArg` and invoked with three arguments; (value, index, array).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to query.\n     * @param {Function|Object|Number|String} [callback|n=1] The function called\n     *  per element or the number of elements to exclude. If a property name or\n     *  object is passed, it will be used to create a \"_.pluck\" or \"_.where\"\n     *  style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.initial([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.initial([1, 2, 3], function(num) {\n     *   return num > 1;\n     * });\n     * // => [1]\n     *\n     * var food = [\n     *   { 'name': 'beet',   'organic': false },\n     *   { 'name': 'carrot', 'organic': true }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.initial(food, 'organic');\n     * // => [{ 'name': 'beet',   'organic': false }]\n     *\n     * var food = [\n     *   { 'name': 'banana', 'type': 'fruit' },\n     *   { 'name': 'beet',   'type': 'vegetable' },\n     *   { 'name': 'carrot', 'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.where\" callback shorthand\n     * _.initial(food, { 'type': 'vegetable' });\n     * // => [{ 'name': 'banana', 'type': 'fruit' }]\n     */\n    function initial(array, callback, thisArg) {\n      if (!array) {\n        return [];\n      }\n      var n = 0,\n          length = array.length;\n\n      if (typeof callback != 'number' && callback != null) {\n        var index = length;\n        callback = lodash.createCallback(callback, thisArg);\n        while (index-- && callback(array[index], index, array)) {\n          n++;\n        }\n      } else {\n        n = (callback == null || thisArg) ? 1 : callback || n;\n      }\n      return slice(array, 0, nativeMin(nativeMax(0, length - n), length));\n    }\n\n    /**\n     * Computes the intersection of all the passed-in arrays using strict equality\n     * for comparisons, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} [array1, array2, ...] Arrays to process.\n     * @returns {Array} Returns a new array of unique elements that are present\n     *  in **all** of the arrays.\n     * @example\n     *\n     * _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);\n     * // => [1, 2]\n     */\n    function intersection(array) {\n      var args = arguments,\n          argsLength = args.length,\n          cache = { '0': {} },\n          index = -1,\n          length = array ? array.length : 0,\n          isLarge = length >= largeArraySize,\n          result = [],\n          seen = result;\n\n      outer:\n      while (++index < length) {\n        var value = array[index];\n        if (isLarge) {\n          var key = keyPrefix + value;\n          var inited = cache[0][key]\n            ? !(seen = cache[0][key])\n            : (seen = cache[0][key] = []);\n        }\n        if (inited || indexOf(seen, value) < 0) {\n          if (isLarge) {\n            seen.push(value);\n          }\n          var argsIndex = argsLength;\n          while (--argsIndex) {\n            if (!(cache[argsIndex] || (cache[argsIndex] = cachedContains(args[argsIndex])))(value)) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the last element of the `array`. If a number `n` is passed, the\n     * last `n` elements of the `array` are returned. If a `callback` function\n     * is passed, elements at the end of the array are returned as long as the\n     * `callback` returns truthy. The `callback` is bound to `thisArg` and\n     * invoked with three arguments;(value, index, array).\n     *\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to query.\n     * @param {Function|Object|Number|String} [callback|n] The function called\n     *  per element or the number of elements to return. If a property name or\n     *  object is passed, it will be used to create a \"_.pluck\" or \"_.where\"\n     *  style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Mixed} Returns the last element(s) of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     *\n     * _.last([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.last([1, 2, 3], function(num) {\n     *   return num > 1;\n     * });\n     * // => [2, 3]\n     *\n     * var food = [\n     *   { 'name': 'beet',   'organic': false },\n     *   { 'name': 'carrot', 'organic': true }\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.last(food, 'organic');\n     * // => [{ 'name': 'carrot', 'organic': true }]\n     *\n     * var food = [\n     *   { 'name': 'banana', 'type': 'fruit' },\n     *   { 'name': 'beet',   'type': 'vegetable' },\n     *   { 'name': 'carrot', 'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.where\" callback shorthand\n     * _.last(food, { 'type': 'vegetable' });\n     * // => [{ 'name': 'beet', 'type': 'vegetable' }, { 'name': 'carrot', 'type': 'vegetable' }]\n     */\n    function last(array, callback, thisArg) {\n      if (array) {\n        var n = 0,\n            length = array.length;\n\n        if (typeof callback != 'number' && callback != null) {\n          var index = length;\n          callback = lodash.createCallback(callback, thisArg);\n          while (index-- && callback(array[index], index, array)) {\n            n++;\n          }\n        } else {\n          n = callback;\n          if (n == null || thisArg) {\n            return array[length - 1];\n          }\n        }\n        return slice(array, nativeMax(0, length - n));\n      }\n    }\n\n    /**\n     * Gets the index at which the last occurrence of `value` is found using strict\n     * equality for comparisons, i.e. `===`. If `fromIndex` is negative, it is used\n     * as the offset from the end of the collection.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to search.\n     * @param {Mixed} value The value to search for.\n     * @param {Number} [fromIndex=array.length-1] The index to search from.\n     * @returns {Number} Returns the index of the matched value or `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);\n     * // => 4\n     *\n     * _.lastIndexOf([1, 2, 3, 1, 2, 3], 2, 3);\n     * // => 1\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var index = array ? array.length : 0;\n      if (typeof fromIndex == 'number') {\n        index = (fromIndex < 0 ? nativeMax(0, index + fromIndex) : nativeMin(fromIndex, index - 1)) + 1;\n      }\n      while (index--) {\n        if (array[index] === value) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to but not including `end`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Number} [start=0] The start of the range.\n     * @param {Number} end The end of the range.\n     * @param {Number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns a new range array.\n     * @example\n     *\n     * _.range(10);\n     * // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n     *\n     * _.range(1, 11);\n     * // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n     *\n     * _.range(0, 30, 5);\n     * // => [0, 5, 10, 15, 20, 25]\n     *\n     * _.range(0, -10, -1);\n     * // => [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]\n     *\n     * _.range(0);\n     * // => []\n     */\n    function range(start, end, step) {\n      start = +start || 0;\n      step = +step || 1;\n\n      if (end == null) {\n        end = start;\n        start = 0;\n      }\n      // use `Array(length)` so V8 will avoid the slower \"dictionary\" mode\n      // http://youtu.be/XAqIpGU8ZZk#t=17m25s\n      var index = -1,\n          length = nativeMax(0, ceil((end - start) / step)),\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * The opposite of `_.initial`, this method gets all but the first value of\n     * `array`. If a number `n` is passed, the first `n` values are excluded from\n     * the result. If a `callback` function is passed, elements at the beginning\n     * of the array are excluded from the result as long as the `callback` returns\n     * truthy. The `callback` is bound to `thisArg` and invoked with three\n     * arguments; (value, index, array).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias drop, tail\n     * @category Arrays\n     * @param {Array} array The array to query.\n     * @param {Function|Object|Number|String} [callback|n=1] The function called\n     *  per element or the number of elements to exclude. If a property name or\n     *  object is passed, it will be used to create a \"_.pluck\" or \"_.where\"\n     *  style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a slice of `array`.\n     * @example\n     *\n     * _.rest([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.rest([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.rest([1, 2, 3], function(num) {\n     *   return num < 3;\n     * });\n     * // => [3]\n     *\n     * var food = [\n     *   { 'name': 'banana', 'organic': true },\n     *   { 'name': 'beet',   'organic': false },\n     * ];\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.rest(food, 'organic');\n     * // => [{ 'name': 'beet', 'organic': false }]\n     *\n     * var food = [\n     *   { 'name': 'apple',  'type': 'fruit' },\n     *   { 'name': 'banana', 'type': 'fruit' },\n     *   { 'name': 'beet',   'type': 'vegetable' }\n     * ];\n     *\n     * // using \"_.where\" callback shorthand\n     * _.rest(food, { 'type': 'fruit' });\n     * // => [{ 'name': 'beet', 'type': 'vegetable' }]\n     */\n    function rest(array, callback, thisArg) {\n      if (typeof callback != 'number' && callback != null) {\n        var n = 0,\n            index = -1,\n            length = array ? array.length : 0;\n\n        callback = lodash.createCallback(callback, thisArg);\n        while (++index < length && callback(array[index], index, array)) {\n          n++;\n        }\n      } else {\n        n = (callback == null || thisArg) ? 1 : nativeMax(0, callback);\n      }\n      return slice(array, n);\n    }\n\n    /**\n     * Uses a binary search to determine the smallest index at which the `value`\n     * should be inserted into `array` in order to maintain the sort order of the\n     * sorted `array`. If `callback` is passed, it will be executed for `value` and\n     * each element in `array` to compute their sort ranking. The `callback` is\n     * bound to `thisArg` and invoked with one argument; (value).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to inspect.\n     * @param {Mixed} value The value to evaluate.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Number} Returns the index at which the value should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([20, 30, 50], 40);\n     * // => 2\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.sortedIndex([{ 'x': 20 }, { 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');\n     * // => 2\n     *\n     * var dict = {\n     *   'wordToNumber': { 'twenty': 20, 'thirty': 30, 'fourty': 40, 'fifty': 50 }\n     * };\n     *\n     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {\n     *   return dict.wordToNumber[word];\n     * });\n     * // => 2\n     *\n     * _.sortedIndex(['twenty', 'thirty', 'fifty'], 'fourty', function(word) {\n     *   return this.wordToNumber[word];\n     * }, dict);\n     * // => 2\n     */\n    function sortedIndex(array, value, callback, thisArg) {\n      var low = 0,\n          high = array ? array.length : low;\n\n      // explicitly reference `identity` for better inlining in Firefox\n      callback = callback ? lodash.createCallback(callback, thisArg, 1) : identity;\n      value = callback(value);\n\n      while (low < high) {\n        var mid = (low + high) >>> 1;\n        (callback(array[mid]) < value)\n          ? low = mid + 1\n          : high = mid;\n      }\n      return low;\n    }\n\n    /**\n     * Computes the union of the passed-in arrays using strict equality for\n     * comparisons, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} [array1, array2, ...] Arrays to process.\n     * @returns {Array} Returns a new array of unique values, in order, that are\n     *  present in one or more of the arrays.\n     * @example\n     *\n     * _.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);\n     * // => [1, 2, 3, 101, 10]\n     */\n    function union(array) {\n      if (!isArray(array)) {\n        arguments[0] = array ? nativeSlice.call(array) : arrayRef;\n      }\n      return uniq(concat.apply(arrayRef, arguments));\n    }\n\n    /**\n     * Creates a duplicate-value-free version of the `array` using strict equality\n     * for comparisons, i.e. `===`. If the `array` is already sorted, passing `true`\n     * for `isSorted` will run a faster algorithm. If `callback` is passed, each\n     * element of `array` is passed through a `callback` before uniqueness is computed.\n     * The `callback` is bound to `thisArg` and invoked with three arguments; (value, index, array).\n     *\n     * If a property name is passed for `callback`, the created \"_.pluck\" style\n     * callback will return the property value of the given element.\n     *\n     * If an object is passed for `callback`, the created \"_.where\" style callback\n     * will return `true` for elements that have the properties of the given object,\n     * else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias unique\n     * @category Arrays\n     * @param {Array} array The array to process.\n     * @param {Boolean} [isSorted=false] A flag to indicate that the `array` is already sorted.\n     * @param {Function|Object|String} [callback=identity] The function called per\n     *  iteration. If a property name or object is passed, it will be used to create\n     *  a \"_.pluck\" or \"_.where\" style callback, respectively.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a duplicate-value-free array.\n     * @example\n     *\n     * _.uniq([1, 2, 1, 3, 1]);\n     * // => [1, 2, 3]\n     *\n     * _.uniq([1, 1, 2, 2, 3], true);\n     * // => [1, 2, 3]\n     *\n     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return Math.floor(num); });\n     * // => [1, 2, 3]\n     *\n     * _.uniq([1, 2, 1.5, 3, 2.5], function(num) { return this.floor(num); }, Math);\n     * // => [1, 2, 3]\n     *\n     * // using \"_.pluck\" callback shorthand\n     * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniq(array, isSorted, callback, thisArg) {\n      var index = -1,\n          length = array ? array.length : 0,\n          result = [],\n          seen = result;\n\n      // juggle arguments\n      if (typeof isSorted != 'boolean' && isSorted != null) {\n        thisArg = callback;\n        callback = isSorted;\n        isSorted = false;\n      }\n      // init value cache for large arrays\n      var isLarge = !isSorted && length >= largeArraySize;\n      if (isLarge) {\n        var cache = {};\n      }\n      if (callback != null) {\n        seen = [];\n        callback = lodash.createCallback(callback, thisArg);\n      }\n      while (++index < length) {\n        var value = array[index],\n            computed = callback ? callback(value, index, array) : value;\n\n        if (isLarge) {\n          var key = keyPrefix + computed;\n          var inited = cache[key]\n            ? !(seen = cache[key])\n            : (seen = cache[key] = []);\n        }\n        if (isSorted\n              ? !index || seen[seen.length - 1] !== computed\n              : inited || indexOf(seen, computed) < 0\n            ) {\n          if (callback || isLarge) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The inverse of `_.zip`, this method splits groups of elements into arrays\n     * composed of elements from each group at their corresponding indexes.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to process.\n     * @returns {Array} Returns a new array of the composed arrays.\n     * @example\n     *\n     * _.unzip([['moe', 30, true], ['larry', 40, false]]);\n     * // => [['moe', 'larry'], [30, 40], [true, false]];\n     */\n    function unzip(array) {\n      var index = -1,\n          length = array ? array.length : 0,\n          tupleLength = length ? max(pluck(array, 'length')) : 0,\n          result = Array(tupleLength);\n\n      while (++index < length) {\n        var tupleIndex = -1,\n            tuple = array[index];\n\n        while (++tupleIndex < tupleLength) {\n          (result[tupleIndex] || (result[tupleIndex] = Array(length)))[index] = tuple[tupleIndex];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all occurrences of the passed values removed using\n     * strict equality for comparisons, i.e. `===`.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} array The array to filter.\n     * @param {Mixed} [value1, value2, ...] Values to remove.\n     * @returns {Array} Returns a new filtered array.\n     * @example\n     *\n     * _.without([1, 2, 1, 0, 3, 1, 4], 0, 1);\n     * // => [2, 3, 4]\n     */\n    function without(array) {\n      return difference(array, nativeSlice.call(arguments, 1));\n    }\n\n    /**\n     * Groups the elements of each array at their corresponding indexes. Useful for\n     * separate data sources that are coordinated through matching array indexes.\n     * For a matrix of nested arrays, `_.zip.apply(...)` can transpose the matrix\n     * in a similar fashion.\n     *\n     * @static\n     * @memberOf _\n     * @category Arrays\n     * @param {Array} [array1, array2, ...] Arrays to process.\n     * @returns {Array} Returns a new array of grouped elements.\n     * @example\n     *\n     * _.zip(['moe', 'larry'], [30, 40], [true, false]);\n     * // => [['moe', 30, true], ['larry', 40, false]]\n     */\n    function zip(array) {\n      var index = -1,\n          length = array ? max(pluck(arguments, 'length')) : 0,\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = pluck(arguments, index);\n      }\n      return result;\n    }\n\n    /**\n     * Creates an object composed from arrays of `keys` and `values`. Pass either\n     * a single two dimensional array, i.e. `[[key1, value1], [key2, value2]]`, or\n     * two arrays, one of `keys` and one of corresponding `values`.\n     *\n     * @static\n     * @memberOf _\n     * @alias object\n     * @category Arrays\n     * @param {Array} keys The array of keys.\n     * @param {Array} [values=[]] The array of values.\n     * @returns {Object} Returns an object composed of the given keys and\n     *  corresponding values.\n     * @example\n     *\n     * _.zipObject(['moe', 'larry'], [30, 40]);\n     * // => { 'moe': 30, 'larry': 40 }\n     */\n    function zipObject(keys, values) {\n      var index = -1,\n          length = keys ? keys.length : 0,\n          result = {};\n\n      while (++index < length) {\n        var key = keys[index];\n        if (values) {\n          result[key] = values[index];\n        } else {\n          result[key[0]] = key[1];\n        }\n      }\n      return result;\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * If `n` is greater than `0`, a function is created that is restricted to\n     * executing `func`, with the `this` binding and arguments of the created\n     * function, only after it is called `n` times. If `n` is less than `1`,\n     * `func` is executed immediately, without a `this` binding or additional\n     * arguments, and its result is returned.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Number} n The number of times the function must be called before\n     * it is executed.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var renderNotes = _.after(notes.length, render);\n     * _.forEach(notes, function(note) {\n     *   note.asyncSave({ 'success': renderNotes });\n     * });\n     * // `renderNotes` is run once, after all notes have saved\n     */\n    function after(n, func) {\n      if (n < 1) {\n        return func();\n      }\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that, when called, invokes `func` with the `this`\n     * binding of `thisArg` and prepends any additional `bind` arguments to those\n     * passed to the bound function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to bind.\n     * @param {Mixed} [thisArg] The `this` binding of `func`.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var func = function(greeting) {\n     *   return greeting + ' ' + this.name;\n     * };\n     *\n     * func = _.bind(func, { 'name': 'moe' }, 'hi');\n     * func();\n     * // => 'hi moe'\n     */\n    function bind(func, thisArg) {\n      // use `Function#bind` if it exists and is fast\n      // (in V8 `Function#bind` is slower except when partially applied)\n      return support.fastBind || (nativeBind && arguments.length > 2)\n        ? nativeBind.call.apply(nativeBind, arguments)\n        : createBound(func, thisArg, nativeSlice.call(arguments, 2));\n    }\n\n    /**\n     * Binds methods on `object` to `object`, overwriting the existing method.\n     * Method names may be specified as individual arguments or as arrays of method\n     * names. If no method names are provided, all the function properties of `object`\n     * will be bound.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {String} [methodName1, methodName2, ...] Method names on the object to bind.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *  'label': 'docs',\n     *  'onClick': function() { alert('clicked ' + this.label); }\n     * };\n     *\n     * _.bindAll(view);\n     * jQuery('#docs').on('click', view.onClick);\n     * // => alerts 'clicked docs', when the button is clicked\n     */\n    function bindAll(object) {\n      var funcs = arguments.length > 1 ? concat.apply(arrayRef, nativeSlice.call(arguments, 1)) : functions(object),\n          index = -1,\n          length = funcs.length;\n\n      while (++index < length) {\n        var key = funcs[index];\n        object[key] = bind(object[key], object);\n      }\n      return object;\n    }\n\n    /**\n     * Creates a function that, when called, invokes the method at `object[key]`\n     * and prepends any additional `bindKey` arguments to those passed to the bound\n     * function. This method differs from `_.bind` by allowing bound functions to\n     * reference methods that will be redefined or don't yet exist.\n     * See http://michaux.ca/articles/lazy-function-definition-pattern.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Object} object The object the method belongs to.\n     * @param {String} key The key of the method.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'name': 'moe',\n     *   'greet': function(greeting) {\n     *     return greeting + ' ' + this.name;\n     *   }\n     * };\n     *\n     * var func = _.bindKey(object, 'greet', 'hi');\n     * func();\n     * // => 'hi moe'\n     *\n     * object.greet = function(greeting) {\n     *   return greeting + ', ' + this.name + '!';\n     * };\n     *\n     * func();\n     * // => 'hi, moe!'\n     */\n    function bindKey(object, key) {\n      return createBound(object, key, nativeSlice.call(arguments, 2), indicatorObject);\n    }\n\n    /**\n     * Creates a function that is the composition of the passed functions,\n     * where each function consumes the return value of the function that follows.\n     * For example, composing the functions `f()`, `g()`, and `h()` produces `f(g(h()))`.\n     * Each function is executed with the `this` binding of the composed function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} [func1, func2, ...] Functions to compose.\n     * @returns {Function} Returns the new composed function.\n     * @example\n     *\n     * var greet = function(name) { return 'hi ' + name; };\n     * var exclaim = function(statement) { return statement + '!'; };\n     * var welcome = _.compose(exclaim, greet);\n     * welcome('moe');\n     * // => 'hi moe!'\n     */\n    function compose() {\n      var funcs = arguments;\n      return function() {\n        var args = arguments,\n            length = funcs.length;\n\n        while (length--) {\n          args = [funcs[length].apply(this, args)];\n        }\n        return args[0];\n      };\n    }\n\n    /**\n     * Produces a callback bound to an optional `thisArg`. If `func` is a property\n     * name, the created callback will return the property value for a given element.\n     * If `func` is an object, the created callback will return `true` for elements\n     * that contain the equivalent object properties, otherwise it will return `false`.\n     *\n     * Note: All Lo-Dash methods, that accept a `callback` argument, use `_.createCallback`.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Mixed} [func=identity] The value to convert to a callback.\n     * @param {Mixed} [thisArg] The `this` binding of the created callback.\n     * @param {Number} [argCount=3] The number of arguments the callback accepts.\n     * @returns {Function} Returns a callback function.\n     * @example\n     *\n     * var stooges = [\n     *   { 'name': 'moe', 'age': 40 },\n     *   { 'name': 'larry', 'age': 50 }\n     * ];\n     *\n     * // wrap to create custom callback shorthands\n     * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {\n     *   var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);\n     *   return !match ? func(callback, thisArg) : function(object) {\n     *     return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];\n     *   };\n     * });\n     *\n     * _.filter(stooges, 'age__gt45');\n     * // => [{ 'name': 'larry', 'age': 50 }]\n     *\n     * // create mixins with support for \"_.pluck\" and \"_.where\" callback shorthands\n     * _.mixin({\n     *   'toLookup': function(collection, callback, thisArg) {\n     *     callback = _.createCallback(callback, thisArg);\n     *     return _.reduce(collection, function(result, value, index, collection) {\n     *       return (result[callback(value, index, collection)] = value, result);\n     *     }, {});\n     *   }\n     * });\n     *\n     * _.toLookup(stooges, 'name');\n     * // => { 'moe': { 'name': 'moe', 'age': 40 }, 'larry': { 'name': 'larry', 'age': 50 } }\n     */\n    function createCallback(func, thisArg, argCount) {\n      if (func == null) {\n        return identity;\n      }\n      var type = typeof func;\n      if (type != 'function') {\n        if (type != 'object') {\n          return function(object) {\n            return object[func];\n          };\n        }\n        var props = keys(func);\n        return function(object) {\n          var length = props.length,\n              result = false;\n          while (length--) {\n            if (!(result = isEqual(object[props[length]], func[props[length]], indicatorObject))) {\n              break;\n            }\n          }\n          return result;\n        };\n      }\n      if (typeof thisArg != 'undefined') {\n        if (argCount === 1) {\n          return function(value) {\n            return func.call(thisArg, value);\n          };\n        }\n        if (argCount === 2) {\n          return function(a, b) {\n            return func.call(thisArg, a, b);\n          };\n        }\n        if (argCount === 4) {\n          return function(accumulator, value, index, collection) {\n            return func.call(thisArg, accumulator, value, index, collection);\n          };\n        }\n        return function(value, index, collection) {\n          return func.call(thisArg, value, index, collection);\n        };\n      }\n      return func;\n    }\n\n    /**\n     * Creates a function that will delay the execution of `func` until after\n     * `wait` milliseconds have elapsed since the last time it was invoked. Pass\n     * an `options` object to indicate that `func` should be invoked on the leading\n     * and/or trailing edge of the `wait` timeout. Subsequent calls to the debounced\n     * function will return the result of the last `func` call.\n     *\n     * Note: If `leading` and `trailing` options are `true`, `func` will be called\n     * on the trailing edge of the timeout only if the the debounced function is\n     * invoked more than once during the `wait` timeout.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to debounce.\n     * @param {Number} wait The number of milliseconds to delay.\n     * @param {Object} options The options object.\n     *  [leading=false] A boolean to specify execution on the leading edge of the timeout.\n     *  [trailing=true] A boolean to specify execution on the trailing edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * var lazyLayout = _.debounce(calculateLayout, 300);\n     * jQuery(window).on('resize', lazyLayout);\n     *\n     * jQuery('#postbox').on('click', _.debounce(sendMail, 200, {\n     *   'leading': true,\n     *   'trailing': false\n     * });\n     */\n    function debounce(func, wait, options) {\n      var args,\n          inited,\n          result,\n          thisArg,\n          timeoutId,\n          trailing = true;\n\n      function delayed() {\n        inited = timeoutId = null;\n        if (trailing) {\n          result = func.apply(thisArg, args);\n        }\n      }\n      if (options === true) {\n        var leading = true;\n        trailing = false;\n      } else if (options && objectTypes[typeof options]) {\n        leading = options.leading;\n        trailing = 'trailing' in options ? options.trailing : trailing;\n      }\n      return function() {\n        args = arguments;\n        thisArg = this;\n        clearTimeout(timeoutId);\n\n        if (!inited && leading) {\n          inited = true;\n          result = func.apply(thisArg, args);\n        } else {\n          timeoutId = setTimeout(delayed, wait);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Defers executing the `func` function until the current call stack has cleared.\n     * Additional arguments will be passed to `func` when it is invoked.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to defer.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.\n     * @returns {Number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function() { alert('deferred'); });\n     * // returns from the function before `alert` is called\n     */\n    function defer(func) {\n      var args = nativeSlice.call(arguments, 1);\n      return setTimeout(function() { func.apply(undefined, args); }, 1);\n    }\n    // use `setImmediate` if it's available in Node.js\n    if (isV8 && freeModule && typeof setImmediate == 'function') {\n      defer = bind(setImmediate, context);\n    }\n\n    /**\n     * Executes the `func` function after `wait` milliseconds. Additional arguments\n     * will be passed to `func` when it is invoked.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to delay.\n     * @param {Number} wait The number of milliseconds to delay execution.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the function with.\n     * @returns {Number} Returns the timer id.\n     * @example\n     *\n     * var log = _.bind(console.log, console);\n     * _.delay(log, 1000, 'logged later');\n     * // => 'logged later' (Appears after one second.)\n     */\n    function delay(func, wait) {\n      var args = nativeSlice.call(arguments, 2);\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * passed, it will be used to determine the cache key for storing the result\n     * based on the arguments passed to the memoized function. By default, the first\n     * argument passed to the memoized function is used as the cache key. The `func`\n     * is executed with the `this` binding of the memoized function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] A function used to resolve the cache key.\n     * @returns {Function} Returns the new memoizing function.\n     * @example\n     *\n     * var fibonacci = _.memoize(function(n) {\n     *   return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);\n     * });\n     */\n    function memoize(func, resolver) {\n      var cache = {};\n      return function() {\n        var key = keyPrefix + (resolver ? resolver.apply(this, arguments) : arguments[0]);\n        return hasOwnProperty.call(cache, key)\n          ? cache[key]\n          : (cache[key] = func.apply(this, arguments));\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to execute `func` once. Repeat calls to\n     * the function will return the value of the first call. The `func` is executed\n     * with the `this` binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // `initialize` executes `createApplication` once\n     */\n    function once(func) {\n      var ran,\n          result;\n\n      return function() {\n        if (ran) {\n          return result;\n        }\n        ran = true;\n        result = func.apply(this, arguments);\n\n        // clear the `func` variable so the function may be garbage collected\n        func = null;\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that, when called, invokes `func` with any additional\n     * `partial` arguments prepended to those passed to the new function. This\n     * method is similar to `_.bind`, except it does **not** alter the `this` binding.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * var greet = function(greeting, name) { return greeting + ' ' + name; };\n     * var hi = _.partial(greet, 'hi');\n     * hi('moe');\n     * // => 'hi moe'\n     */\n    function partial(func) {\n      return createBound(func, nativeSlice.call(arguments, 1));\n    }\n\n    /**\n     * This method is similar to `_.partial`, except that `partial` arguments are\n     * appended to those passed to the new function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {Mixed} [arg1, arg2, ...] Arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * var defaultsDeep = _.partialRight(_.merge, _.defaults);\n     *\n     * var options = {\n     *   'variable': 'data',\n     *   'imports': { 'jq': $ }\n     * };\n     *\n     * defaultsDeep(options, _.templateSettings);\n     *\n     * options.variable\n     * // => 'data'\n     *\n     * options.imports\n     * // => { '_': _, 'jq': $ }\n     */\n    function partialRight(func) {\n      return createBound(func, nativeSlice.call(arguments, 1), null, indicatorObject);\n    }\n\n    /**\n     * Creates a function that, when executed, will only call the `func` function\n     * at most once per every `wait` milliseconds. Pass an `options` object to\n     * indicate that `func` should be invoked on the leading and/or trailing edge\n     * of the `wait` timeout. Subsequent calls to the throttled function will\n     * return the result of the last `func` call.\n     *\n     * Note: If `leading` and `trailing` options are `true`, `func` will be called\n     * on the trailing edge of the timeout only if the the throttled function is\n     * invoked more than once during the `wait` timeout.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Function} func The function to throttle.\n     * @param {Number} wait The number of milliseconds to throttle executions to.\n     * @param {Object} options The options object.\n     *  [leading=true] A boolean to specify execution on the leading edge of the timeout.\n     *  [trailing=true] A boolean to specify execution on the trailing edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * var throttled = _.throttle(updatePosition, 100);\n     * jQuery(window).on('scroll', throttled);\n     *\n     * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {\n     *   'trailing': false\n     * }));\n     */\n    function throttle(func, wait, options) {\n      var args,\n          result,\n          thisArg,\n          timeoutId,\n          lastCalled = 0,\n          leading = true,\n          trailing = true;\n\n      function trailingCall() {\n        timeoutId = null;\n        if (trailing) {\n          lastCalled = new Date;\n          result = func.apply(thisArg, args);\n        }\n      }\n      if (options === false) {\n        leading = false;\n      } else if (options && objectTypes[typeof options]) {\n        leading = 'leading' in options ? options.leading : leading;\n        trailing = 'trailing' in options ? options.trailing : trailing;\n      }\n      return function() {\n        var now = new Date;\n        if (!timeoutId && !leading) {\n          lastCalled = now;\n        }\n        var remaining = wait - (now - lastCalled);\n        args = arguments;\n        thisArg = this;\n\n        if (remaining <= 0) {\n          clearTimeout(timeoutId);\n          timeoutId = null;\n          lastCalled = now;\n          result = func.apply(thisArg, args);\n        }\n        else if (!timeoutId) {\n          timeoutId = setTimeout(trailingCall, remaining);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that passes `value` to the `wrapper` function as its\n     * first argument. Additional arguments passed to the function are appended\n     * to those passed to the `wrapper` function. The `wrapper` is executed with\n     * the `this` binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @category Functions\n     * @param {Mixed} value The value to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var hello = function(name) { return 'hello ' + name; };\n     * hello = _.wrap(hello, function(func) {\n     *   return 'before, ' + func('moe') + ', after';\n     * });\n     * hello();\n     * // => 'before, hello moe, after'\n     */\n    function wrap(value, wrapper) {\n      return function() {\n        var args = [value];\n        push.apply(args, arguments);\n        return wrapper.apply(this, args);\n      };\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Converts the characters `&`, `<`, `>`, `\"`, and `'` in `string` to their\n     * corresponding HTML entities.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {String} string The string to escape.\n     * @returns {String} Returns the escaped string.\n     * @example\n     *\n     * _.escape('Moe, Larry & Curly');\n     * // => 'Moe, Larry &amp; Curly'\n     */\n    function escape(string) {\n      return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);\n    }\n\n    /**\n     * This function returns the first argument passed to it.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {Mixed} value Any value.\n     * @returns {Mixed} Returns `value`.\n     * @example\n     *\n     * var moe = { 'name': 'moe' };\n     * moe === _.identity(moe);\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Adds functions properties of `object` to the `lodash` function and chainable\n     * wrapper.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {Object} object The object of function properties to add to `lodash`.\n     * @example\n     *\n     * _.mixin({\n     *   'capitalize': function(string) {\n     *     return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();\n     *   }\n     * });\n     *\n     * _.capitalize('moe');\n     * // => 'Moe'\n     *\n     * _('moe').capitalize();\n     * // => 'Moe'\n     */\n    function mixin(object) {\n      forEach(functions(object), function(methodName) {\n        var func = lodash[methodName] = object[methodName];\n\n        lodash.prototype[methodName] = function() {\n          var value = this.__wrapped__,\n              args = [value];\n\n          push.apply(args, arguments);\n          var result = func.apply(lodash, args);\n          return (value && typeof value == 'object' && value == result)\n            ? this\n            : new lodashWrapper(result);\n        };\n      });\n    }\n\n    /**\n     * Reverts the '_' variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      context._ = oldDash;\n      return this;\n    }\n\n    /**\n     * Converts the given `value` into an integer of the specified `radix`.\n     * If `radix` is `undefined` or `0`, a `radix` of `10` is used unless the\n     * `value` is a hexadecimal, in which case a `radix` of `16` is used.\n     *\n     * Note: This method avoids differences in native ES3 and ES5 `parseInt`\n     * implementations. See http://es5.github.com/#E.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {String} value The value to parse.\n     * @param {Number} [radix] The radix used to interpret the value to parse.\n     * @returns {Number} Returns the new integer value.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     */\n    var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {\n      // Firefox and Opera still follow the ES3 specified implementation of `parseInt`\n      return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);\n    };\n\n    /**\n     * Produces a random number between `min` and `max` (inclusive). If only one\n     * argument is passed, a number between `0` and the given number will be returned.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {Number} [min=0] The minimum possible value.\n     * @param {Number} [max=1] The maximum possible value.\n     * @returns {Number} Returns a random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => a number between 0 and 5\n     *\n     * _.random(5);\n     * // => also a number between 0 and 5\n     */\n    function random(min, max) {\n      if (min == null && max == null) {\n        max = 1;\n      }\n      min = +min || 0;\n      if (max == null) {\n        max = min;\n        min = 0;\n      }\n      return min + floor(nativeRandom() * ((+max || 0) - min + 1));\n    }\n\n    /**\n     * Resolves the value of `property` on `object`. If `property` is a function,\n     * it will be invoked with the `this` binding of `object` and its result returned,\n     * else the property value is returned. If `object` is falsey, then `undefined`\n     * is returned.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {Object} object The object to inspect.\n     * @param {String} property The property to get the value of.\n     * @returns {Mixed} Returns the resolved value.\n     * @example\n     *\n     * var object = {\n     *   'cheese': 'crumpets',\n     *   'stuff': function() {\n     *     return 'nonsense';\n     *   }\n     * };\n     *\n     * _.result(object, 'cheese');\n     * // => 'crumpets'\n     *\n     * _.result(object, 'stuff');\n     * // => 'nonsense'\n     */\n    function result(object, property) {\n      var value = object ? object[property] : undefined;\n      return isFunction(value) ? object[property]() : value;\n    }\n\n    /**\n     * A micro-templating method that handles arbitrary delimiters, preserves\n     * whitespace, and correctly escapes quotes within interpolated code.\n     *\n     * Note: In the development build, `_.template` utilizes sourceURLs for easier\n     * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl\n     *\n     * For more information on precompiling templates see:\n     * http://lodash.com/#custom-builds\n     *\n     * For more information on Chrome extension sandboxes see:\n     * http://developer.chrome.com/stable/extensions/sandboxingEval.html\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {String} text The template text.\n     * @param {Object} data The data object used to populate the text.\n     * @param {Object} options The options object.\n     *  escape - The \"escape\" delimiter regexp.\n     *  evaluate - The \"evaluate\" delimiter regexp.\n     *  interpolate - The \"interpolate\" delimiter regexp.\n     *  sourceURL - The sourceURL of the template's compiled source.\n     *  variable - The data object variable name.\n     * @returns {Function|String} Returns a compiled function when no `data` object\n     *  is given, else it returns the interpolated text.\n     * @example\n     *\n     * // using a compiled template\n     * var compiled = _.template('hello <%= name %>');\n     * compiled({ 'name': 'moe' });\n     * // => 'hello moe'\n     *\n     * var list = '<% _.forEach(people, function(name) { %><li><%= name %></li><% }); %>';\n     * _.template(list, { 'people': ['moe', 'larry'] });\n     * // => '<li>moe</li><li>larry</li>'\n     *\n     * // using the \"escape\" delimiter to escape HTML in data property values\n     * _.template('<b><%- value %></b>', { 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // using the ES6 delimiter as an alternative to the default \"interpolate\" delimiter\n     * _.template('hello ${ name }', { 'name': 'curly' });\n     * // => 'hello curly'\n     *\n     * // using the internal `print` function in \"evaluate\" delimiters\n     * _.template('<% print(\"hello \" + epithet); %>!', { 'epithet': 'stooge' });\n     * // => 'hello stooge!'\n     *\n     * // using custom template delimiters\n     * _.templateSettings = {\n     *   'interpolate': /{{([\\s\\S]+?)}}/g\n     * };\n     *\n     * _.template('hello {{ name }}!', { 'name': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // using the `sourceURL` option to specify a custom sourceURL for the template\n     * var compiled = _.template('hello <%= name %>', null, { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector\n     *\n     * // using the `variable` option to ensure a with-statement isn't used in the compiled template\n     * var compiled = _.template('hi <%= data.name %>!', null, { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     *   var __t, __p = '', __e = _.escape;\n     *   __p += 'hi ' + ((__t = ( data.name )) == null ? '' : __t) + '!';\n     *   return __p;\n     * }\n     *\n     * // using the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and a stack trace\n     * fs.writeFileSync(path.join(cwd, 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(text, data, options) {\n      // based on John Resig's `tmpl` implementation\n      // http://ejohn.org/blog/javascript-micro-templating/\n      // and Laura Doktorova's doT.js\n      // https://github.com/olado/doT\n      var settings = lodash.templateSettings;\n      text || (text = '');\n\n      // avoid missing dependencies when `iteratorTemplate` is not defined\n      options = defaults({}, options, settings);\n\n      var imports = defaults({}, options.imports, settings.imports),\n          importsKeys = keys(imports),\n          importsValues = values(imports);\n\n      var isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // compile the regexp to match each delimiter\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      text.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // escape characters that cannot be included in string literals\n        source += text.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // replace delimiters with snippets\n        if (escapeValue) {\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // the JS engine embedded in Adobe products requires returning the `match`\n        // string in order to produce the correct `offset` value\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // if `variable` is not specified, wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain\n      var variable = options.variable,\n          hasVariable = variable;\n\n      if (!hasVariable) {\n        variable = 'obj';\n        source = 'with (' + variable + ') {\\n' + source + '\\n}\\n';\n      }\n      // cleanup code by stripping empty strings\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // frame code as the function body\n      source = 'function(' + variable + ') {\\n' +\n        (hasVariable ? '' : variable + ' || (' + variable + ' = {});\\n') +\n        \"var __t, __p = '', __e = _.escape\" +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      // Use a sourceURL for easier debugging and wrap in a multi-line comment to\n      // avoid issues with Narwhal, IE conditional compilation, and the JS engine\n      // embedded in Adobe products.\n      // http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl\n      var sourceURL = '\\n/*\\n//@ sourceURL=' + (options.sourceURL || '/lodash/template/source[' + (templateCounter++) + ']') + '\\n*/';\n\n      try {\n        var result = Function(importsKeys, 'return ' + source + sourceURL).apply(undefined, importsValues);\n      } catch(e) {\n        e.source = source;\n        throw e;\n      }\n      if (data) {\n        return result(data);\n      }\n      // provide the compiled function's source via its `toString` method, in\n      // supported environments, or the `source` property as a convenience for\n      // inlining compiled templates during the build process\n      result.source = source;\n      return result;\n    }\n\n    /**\n     * Executes the `callback` function `n` times, returning an array of the results\n     * of each `callback` execution. The `callback` is bound to `thisArg` and invoked\n     * with one argument; (index).\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {Number} n The number of times to execute the callback.\n     * @param {Function} callback The function called per iteration.\n     * @param {Mixed} [thisArg] The `this` binding of `callback`.\n     * @returns {Array} Returns a new array of the results of each `callback` execution.\n     * @example\n     *\n     * var diceRolls = _.times(3, _.partial(_.random, 1, 6));\n     * // => [3, 6, 4]\n     *\n     * _.times(3, function(n) { mage.castSpell(n); });\n     * // => calls `mage.castSpell(n)` three times, passing `n` of `0`, `1`, and `2` respectively\n     *\n     * _.times(3, function(n) { this.cast(n); }, mage);\n     * // => also calls `mage.castSpell(n)` three times\n     */\n    function times(n, callback, thisArg) {\n      n = (n = +n) > -1 ? n : 0;\n      var index = -1,\n          result = Array(n);\n\n      callback = lodash.createCallback(callback, thisArg, 1);\n      while (++index < n) {\n        result[index] = callback(index);\n      }\n      return result;\n    }\n\n    /**\n     * The inverse of `_.escape`, this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to their\n     * corresponding characters.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {String} string The string to unescape.\n     * @returns {String} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('Moe, Larry &amp; Curly');\n     * // => 'Moe, Larry & Curly'\n     */\n    function unescape(string) {\n      return string == null ? '' : String(string).replace(reEscapedHtml, unescapeHtmlChar);\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is passed, the ID will be appended to it.\n     *\n     * @static\n     * @memberOf _\n     * @category Utilities\n     * @param {String} [prefix] The value to prefix the ID with.\n     * @returns {String} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return String(prefix == null ? '' : prefix) + id;\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * Invokes `interceptor` with the `value` as the first argument, and then\n     * returns `value`. The purpose of this method is to \"tap into\" a method chain,\n     * in order to perform operations on intermediate results within the chain.\n     *\n     * @static\n     * @memberOf _\n     * @category Chaining\n     * @param {Mixed} value The value to pass to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @returns {Mixed} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3, 4])\n     *  .filter(function(num) { return num % 2 == 0; })\n     *  .tap(alert)\n     *  .map(function(num) { return num * num; })\n     *  .value();\n     * // => // [2, 4] (alerted)\n     * // => [4, 16]\n     */\n    function tap(value, interceptor) {\n      interceptor(value);\n      return value;\n    }\n\n    /**\n     * Produces the `toString` result of the wrapped value.\n     *\n     * @name toString\n     * @memberOf _\n     * @category Chaining\n     * @returns {String} Returns the string result.\n     * @example\n     *\n     * _([1, 2, 3]).toString();\n     * // => '1,2,3'\n     */\n    function wrapperToString() {\n      return String(this.__wrapped__);\n    }\n\n    /**\n     * Extracts the wrapped value.\n     *\n     * @name valueOf\n     * @memberOf _\n     * @alias value\n     * @category Chaining\n     * @returns {Mixed} Returns the wrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).valueOf();\n     * // => [1, 2, 3]\n     */\n    function wrapperValueOf() {\n      return this.__wrapped__;\n    }\n\n    /*--------------------------------------------------------------------------*/\n\n    // add functions that return wrapped values when chaining\n    lodash.after = after;\n    lodash.assign = assign;\n    lodash.at = at;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.compact = compact;\n    lodash.compose = compose;\n    lodash.countBy = countBy;\n    lodash.createCallback = createCallback;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.filter = filter;\n    lodash.flatten = flatten;\n    lodash.forEach = forEach;\n    lodash.forIn = forIn;\n    lodash.forOwn = forOwn;\n    lodash.functions = functions;\n    lodash.groupBy = groupBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.invert = invert;\n    lodash.invoke = invoke;\n    lodash.keys = keys;\n    lodash.map = map;\n    lodash.max = max;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.min = min;\n    lodash.omit = omit;\n    lodash.once = once;\n    lodash.pairs = pairs;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.pick = pick;\n    lodash.pluck = pluck;\n    lodash.range = range;\n    lodash.reject = reject;\n    lodash.rest = rest;\n    lodash.shuffle = shuffle;\n    lodash.sortBy = sortBy;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.times = times;\n    lodash.toArray = toArray;\n    lodash.union = union;\n    lodash.uniq = uniq;\n    lodash.unzip = unzip;\n    lodash.values = values;\n    lodash.where = where;\n    lodash.without = without;\n    lodash.wrap = wrap;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n\n    // add aliases\n    lodash.collect = map;\n    lodash.drop = rest;\n    lodash.each = forEach;\n    lodash.extend = assign;\n    lodash.methods = functions;\n    lodash.object = zipObject;\n    lodash.select = filter;\n    lodash.tail = rest;\n    lodash.unique = uniq;\n\n    // add functions to `lodash.prototype`\n    mixin(lodash);\n\n    /*--------------------------------------------------------------------------*/\n\n    // add functions that return unwrapped values when chaining\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.contains = contains;\n    lodash.escape = escape;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.has = has;\n    lodash.identity = identity;\n    lodash.indexOf = indexOf;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isBoolean = isBoolean;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isNaN = isNaN;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isString = isString;\n    lodash.isUndefined = isUndefined;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.mixin = mixin;\n    lodash.noConflict = noConflict;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.result = result;\n    lodash.runInContext = runInContext;\n    lodash.size = size;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.template = template;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n\n    // add aliases\n    lodash.all = every;\n    lodash.any = some;\n    lodash.detect = find;\n    lodash.foldl = reduce;\n    lodash.foldr = reduceRight;\n    lodash.include = contains;\n    lodash.inject = reduce;\n\n    forOwn(lodash, function(func, methodName) {\n      if (!lodash.prototype[methodName]) {\n        lodash.prototype[methodName] = function() {\n          var args = [this.__wrapped__];\n          push.apply(args, arguments);\n          return func.apply(lodash, args);\n        };\n      }\n    });\n\n    /*--------------------------------------------------------------------------*/\n\n    // add functions capable of returning wrapped and unwrapped values when chaining\n    lodash.first = first;\n    lodash.last = last;\n\n    // add aliases\n    lodash.take = first;\n    lodash.head = first;\n\n    forOwn(lodash, function(func, methodName) {\n      if (!lodash.prototype[methodName]) {\n        lodash.prototype[methodName]= function(callback, thisArg) {\n          var result = func(this.__wrapped__, callback, thisArg);\n          return callback == null || (thisArg && typeof callback != 'function')\n            ? result\n            : new lodashWrapper(result);\n        };\n      }\n    });\n\n    /*--------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type String\n     */\n    lodash.VERSION = '1.2.1';\n\n    // add \"Chaining\" functions to the wrapper\n    lodash.prototype.toString = wrapperToString;\n    lodash.prototype.value = wrapperValueOf;\n    lodash.prototype.valueOf = wrapperValueOf;\n\n    // add `Array` functions that return unwrapped values\n    forEach(['join', 'pop', 'shift'], function(methodName) {\n      var func = arrayRef[methodName];\n      lodash.prototype[methodName] = function() {\n        return func.apply(this.__wrapped__, arguments);\n      };\n    });\n\n    // add `Array` functions that return the wrapped value\n    forEach(['push', 'reverse', 'sort', 'unshift'], function(methodName) {\n      var func = arrayRef[methodName];\n      lodash.prototype[methodName] = function() {\n        func.apply(this.__wrapped__, arguments);\n        return this;\n      };\n    });\n\n    // add `Array` functions that return new wrapped values\n    forEach(['concat', 'slice', 'splice'], function(methodName) {\n      var func = arrayRef[methodName];\n      lodash.prototype[methodName] = function() {\n        return new lodashWrapper(func.apply(this.__wrapped__, arguments));\n      };\n    });\n\n    return lodash;\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  // expose Lo-Dash\n  var _ = runInContext();\n\n  // some AMD build optimizers, like r.js, check for specific condition patterns like the following:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose Lo-Dash to the global object even when an AMD loader is present in\n    // case Lo-Dash was injected by a third-party script and not intended to be\n    // loaded as a module. The global assignment can be reverted in the Lo-Dash\n    // module via its `noConflict()` method.\n    window._ = _;\n\n    // define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module\n    define(function() {\n      return _;\n    });\n  }\n  // check for `exports` after `define` in case a build optimizer adds an `exports` object\n  else if (freeExports && !freeExports.nodeType) {\n    // in Node.js or RingoJS v0.8.0+\n    if (freeModule) {\n      (freeModule.exports = _)._ = _;\n    }\n    // in Narwhal or RingoJS v0.7.0-\n    else {\n      freeExports._ = _;\n    }\n  }\n  else {\n    // in a browser or Rhino\n    window._ = _;\n  }\n}(this));\n\n})(window)","var relativeDate = (function(undefined){\n\n  var SECOND = 1000,\n      MINUTE = 60 * SECOND,\n      HOUR = 60 * MINUTE,\n      DAY = 24 * HOUR,\n      WEEK = 7 * DAY,\n      YEAR = DAY * 365,\n      MONTH = YEAR / 12;\n\n  var formats = [\n    [ 0.7 * MINUTE, 'just now' ],\n    [ 1.5 * MINUTE, 'a minute ago' ],\n    [ 60 * MINUTE, 'minutes ago', MINUTE ],\n    [ 1.5 * HOUR, 'an hour ago' ],\n    [ DAY, 'hours ago', HOUR ],\n    [ 2 * DAY, 'yesterday' ],\n    [ 7 * DAY, 'days ago', DAY ],\n    [ 1.5 * WEEK, 'a week ago'],\n    [ MONTH, 'weeks ago', WEEK ],\n    [ 1.5 * MONTH, 'a month ago' ],\n    [ YEAR, 'months ago', MONTH ],\n    [ 1.5 * YEAR, 'a year ago' ],\n    [ Number.MAX_VALUE, 'years ago', YEAR ]\n  ];\n\n  function relativeDate(input,reference){\n    !reference && ( reference = (new Date).getTime() );\n    reference instanceof Date && ( reference = reference.getTime() );\n    input instanceof Date && ( input = input.getTime() );\n    \n    var delta = reference - input,\n        format, i, len;\n\n    for(i = -1, len=formats.length; ++i < len; ){\n      format = formats[i];\n      if(delta < format[0]){\n        return format[2] == undefined ? format[1] : Math.round(delta/format[2]) + ' ' + format[1];\n      }\n    };\n  }\n\n  return relativeDate;\n\n})();\n\nif(typeof module != 'undefined' && module.exports){\n  module.exports = relativeDate;\n}\n"]}
+;
\ No newline at end of file
diff --git a/browser/browser.js b/browser/browser.js
index 3fa0255eff..736b213083 100644
--- a/browser/browser.js
+++ b/browser/browser.js
@@ -7,7 +7,7 @@ try {
     window;
     window.habitrpgShared = exports;
 } catch(e) {}
-},{"./algos.coffee":2,"./helpers.coffee":3,"./items.coffee":4}],2:[function(require,module,exports){
+},{"./algos.coffee":2,"./items.coffee":3,"./helpers.coffee":4}],2:[function(require,module,exports){
 (function() {
   var HP, XP, hatchingPotions, helpers, items, moment, obj, pets, randomDrop, updateStats, _, _ref,
     __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
@@ -515,7 +515,7 @@ try {
 }).call(this);
 
 
-},{"./helpers.coffee":3,"./items.coffee":4,"moment":5,"lodash":6}],4:[function(require,module,exports){
+},{"./helpers.coffee":4,"./items.coffee":3,"moment":5,"lodash":6}],3:[function(require,module,exports){
 (function() {
   var items, _;
 
@@ -978,7 +978,7 @@ process.chdir = function (dir) {
     throw new Error('process.chdir is not supported');
 };
 
-},{}],3:[function(require,module,exports){
+},{}],4:[function(require,module,exports){
 (function(process){(function() {
   var algos, dayMapping, daysBetween, items, moment, shouldDo, sod, _;
 
@@ -1401,7 +1401,7 @@ process.chdir = function (dir) {
 
 
 })(require("__browserify_process"))
-},{"./algos.coffee":2,"./items.coffee":4,"moment":5,"lodash":6,"relative-date":8,"__browserify_process":7}],5:[function(require,module,exports){
+},{"./items.coffee":3,"./algos.coffee":2,"moment":5,"lodash":6,"relative-date":8,"__browserify_process":7}],5:[function(require,module,exports){
 (function(){// moment.js
 // version : 2.0.0
 // author : Tim Wood