surveyman.main.js

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	/**
	 * Created by etosch on 6/10/16.
	 */

	window.SurveyMan = {
	    "surveyman": __webpack_require__(1),
	    "display": __webpack_require__(6),
	    "config": __webpack_require__(5)
	};

	window.$ = __webpack_require__(8);

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

	/**
	 * @fileoverview
	 * <h2>Overview</h2>
	 * The surveyman.js repository contains three modules. Together these three modules form the SurveyMan runtime system, contained in the SurveyMan namespace. This runtime system receives a JSON representation of a survey and executes that survey (with the help of a human!) in a browser. These three modules are meant to be used with the SurveyMan server and static analyzer.
	 *
	 * Currently this code expects to be executed inside https://github.com/SurveyMan/Runner/blob/master/src/main/resources/HTMLSkeleton.html.
	 *
	 * <h2>Install</h2>
	 *
	 * <tt>npm install surveyman</tt>
	 *
	 * <h2>Usage</h2>
	 * <p><i>Warning: These instructions are deprecated</i></p>
	 * <p>If you use these modules with the SurveyMan Java backend, everything is good to go! If you're using your own backend or otherwise modifying some part of the pipeline, you will need to ensure the following are present in your HTML for everything to work:
	 *
	 * <p>First, make sure you have the following in the head:</p>
	 *
	 * <p><tt>&lt;script type="text/javascript" src="http://surveyman.github.io/surveyman.js/deprecated/survey.js"&gt;&lt;/script&gt;<br/>
	      &lt;script type="text/javascript" src="http://surveyman.github.io/surveyman.js/deprecated/interpreter.js"&gt;&lt;/script&gt;<br/>
	      &lt;script type="text/javascript" src="http://surveyman.github.io/surveyman.js/deprecated/display.js"&gt;&lt;/script&gt;</tt>
	  </p>
	 *
	 * <p>If you are using AMT as your backend, you will also need a link to the submission script in the head, per the AMT documentations. If you are using a local backend, you will need some way to capture the assignment id, since it's used to seed the random number generator. The SurveyMan backend generates the following when it is being run locally:</p>
	 *
	 * <p><tt>&lt;script type="text/javascript"&gt;
	   $.ajaxSetup({async:false});<br/>
	   var turkSetAssignmentID = function () { <br/>
	   &nbsp;&nbsp;$.get("assignmentId", function(_aid) { <br/>
	   &nbsp;&nbsp;&nbsp;&nbsp;console.log("Just pulled assignment Id : " + _aid); <br/>
	   &nbsp;&nbsp;&nbsp;&nbsp;document.getElementById("assignmentId").value = _aid.trim(); <br/>
	   &nbsp;&nbsp;&nbsp;&nbsp;aid = _aid; <br/>
	   &nbsp;&nbsp;}); <br/>
	             }; <br/>
	   &lt;/script&gt;</tt></p>
	 *
	 * <p><tt>turkSetAssignmentId</tt> is an AMT-defined function. Since <tt>SurveyMan.display.ready</tt> expects it, we define a local version here. AMT also injects an `assignmentId` element, so when we run locally, we add an element with this id to our form.</p>
	 *
	 * <p>SurveyMan generates a form to be sent with a POST; although a user-defined version could simply collect data in a Javascript object and POST this back to a local server, we wanted to be able to write one version to work with both AMT and a local server.</p>
	 *
	 * <p>At the end of the body, SurveyMan adds the following snippet:</p>
	 *
	 * <tt>
	 &lt;script type='text/javascript'&gt;</br/>
	 &nbsp;&nbsp;turkSetAssignmentID();</br/>
	 &nbsp;&nbsp;var loadPreview=function(){<PROBABLY_A_CONSENT_FORM>},</br/>
	 &nbsp;&nbsp;jsonizedSurvey=<JSONIZED_SURVEY>;</br/>
	 &nbsp;&nbsp;Surveyman.display.ready(jsonizedSurvey, loadPreview);</br/>
	     &lt;/script&gt;
	   </tt>
	 *
	 * <p><i>New instructions, not robustly tested:</i></p>
	 * <p><tt>
	 *
	 */
	//  surveyman.js 0.2.0
	//  http://surveyman.github.io/surveyman.js
	//  (c) 2015 University of Massachusetts Amherst
	//  surveyman.js is released under the CRAPL.

	// Major refactor 9/2015:
	// Bug fixes.
	// Remove underscore.
	// Swap in some ES6 features.
	// Merged interpreter and survey object.

	// API returns Immutable objects to be used in React interface
	// Incremental adds

	__webpack_require__(2);
	var log = __webpack_require__(4);
	var config = __webpack_require__(5);

	/*****************************************************************************
	 * Survey submodule
	 *****************************************************************************/

	// Internal maps from string ids to objects
	// ----------------------------------------
	var blockMAP = new Map(),
	    optionMAP = new Map(),
	    questionMAP = new Map();

	/**
	 * Resets the lookup maps for blocks, options, and questions.
	 */
	var global_reset = function global_reset() {
	  blockMAP.clear();
	  optionMAP.clear();
	  questionMAP.clear();
	};

	// Exceptions
	// ----------
	function SMSurveyException(msg) {
	  var override = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

	  Error.call(this);
	  this.message = override ? msg : 'SMSurveyException: ' + msg;
	  this.stack = new Error().stack;
	}
	SMSurveyException.prototype = Error.prototype;
	SMSurveyException.prototype.constructor = SMSurveyException;

	function UnknownTypeException(thing) {
	  SMSurveyException.call(this);
	  this.message = 'Unknown type for ' + thing + ': (' + (typeof thing === 'undefined' ? 'undefined' : _typeof(thing)) + ')';
	}
	UnknownTypeException.prototype = Object.create(SMSurveyException.prototype);
	UnknownTypeException.prototype.constructor = UnknownTypeException;

	function ObjectNotFoundException(type, id, objName) {
	  SMSurveyException.call(this);
	  this.message = type + ' id ' + id + ' not found in ' + objName;
	}
	ObjectNotFoundException.prototype = Object.create(SMSurveyException.prototype);
	ObjectNotFoundException.prototype.constructor = ObjectNotFoundException;

	function MalformedSurveyException(msg) {
	  SMSurveyException.call(this);
	  this.message = 'Malformed Survey: ' + msg;
	}
	MalformedSurveyException.prototype = Object.create(SMSurveyException.prototype);
	MalformedSurveyException.prototype.constructor = MalformedSurveyException;

	// Utility functions
	// -----------------
	var assertJSONHasProperties = function assertJSONHasProperties(jsonObj) {
	  for (var _len = arguments.length, plist = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	    plist[_key - 1] = arguments[_key];
	  }

	  plist.forEach(function (prop) {
	    return console.assert(jsonObj.hasOwnProperty(prop), "Missing property " + prop);
	  });
	};

	var FYshuffle = function FYshuffle(arr) {
	  // Implementing this here so I don't have to import underscore or lodash.
	  var counter = arr.length;
	  while (counter > 0) {
	    var swapIndex = Math.floor(Math.random() * counter);
	    var swapObj = arr[swapIndex];
	    arr[swapIndex] = arr[counter - 1];
	    arr[counter - 1] = swapObj;
	    counter--;
	  }
	};

	var sortById = function sortById(lst) {
	  // Bubble sort, yo!
	  // We generally expect these to already be sorted.
	  while (true) {
	    // eslint-disable-line no-constant-condition
	    var swapped = false;
	    for (var j = 0; j < lst.length - 1; j++) {
	      var b1 = lst[j];
	      var b2 = lst[j + 1];
	      // getting some weirdness earlier; not sure why
	      if (b1.idComp(b2) === 1) {
	        log.info('swapping blocks ' + b1.id + ' and ' + b2.id);
	        swapped = true;
	        lst[j] = b2;
	        lst[j + 1] = b1;
	      }
	    }
	    // if there were no swaps, then we are already sorted.
	    if (!swapped) return;
	  }
	};

	/**
	 * Gets the Option object from the internal mapping of ids to Options.
	 * Throws an exception if the id is not found.
	 * @param {string} oid The option id.
	 * @returns {Option}
	 */
	var getOptionById = function getOptionById(oid) {
	  if (optionMAP.has(oid)) {
	    return optionMAP.get(oid);
	  }
	  throw new ObjectNotFoundException('Option', oid, 'optionMAP');
	};

	/**
	 * Gets the Question object from the internal mapping of ids to Questions.
	 * Throws an exception if the id is not found.
	 * @param {string} quid The question id.
	 * @returns {Question}
	 */
	var getQuestionById = function getQuestionById(quid) {
	  if (questionMAP.has(quid)) {
	    return questionMAP.get(quid);
	  } else throw new ObjectNotFoundException('Question', quid, 'questionMAP');
	};

	/**
	 * Gets the Block object from the internal mapping of ids to Blocks.
	 * Throws an exception if the id is not found.
	 * @param {string} bid The block id. May be null.
	 * @returns {Block}
	 */
	var getBlockById = function getBlockById(bid) {
	  if (bid === null) return null;
	  if (blockMAP.has(bid)) {
	    return blockMAP.get(bid);
	  } else throw new ObjectNotFoundException('Object', bid, 'blockMAP');
	};

	/**
	 * This function parses some object to a boolean, returning the default value
	 * if the first argument is undefined. It is exported as a 'private' variable
	 * in the SurveyMan.survey object.
	 *
	 * The parsed object may return:
	 * <ul>
	 * <li>boolean, for most question fields (e.g., randomize, exclusive, etc.)</li>
	 * <li>string or regexp, for the freetext field</li>
	 * <li>boolean or an array for option ids, for the ordered field</li>
	 * </ul>
	 *
	 * @param {*} thing Any object, possibly undefined.
	 * @param {*} defaultVal The default value for this object; may not be undefined.
	 * @param {Question} question This is provided for backwards compatibility on the
	 * json schema and may be undefined. The 'ordered' field for questions may be a
	 * boolean (old version) or an array of option ids (new version).
	 * @returns {*} the parsed object
	 */
	var parseBools = function parseBools(thing, defaultVal) {
	  var question = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];

	  console.assert(defaultVal !== undefined, 'Default value cannot be undefined.');
	  if (thing === undefined) {
	    return defaultVal;
	  } else if (typeof thing === 'string') {
	    try {
	      return JSON.parse(thing);
	    } catch (err) {
	      return thing;
	    }
	  } else if (typeof thing === 'boolean') {
	    return thing;
	  } else if (Array.isArray(thing)) {
	    // New schemata spec for ordered -- provides a list of the ids that are
	    // ordered for this question.
	    // Set the initial ids of the question's options
	    question.options = thing.map(function (oid) {
	      return getOptionById(oid);
	    });
	    return true;
	  }
	  throw new UnknownTypeException(thing);
	};

	/**
	 * The Option object holds answer options. It has three fields:
	 * <ul>
	 *     <li><b>id</b> string representing the internal id of this option</li>
	 *     <li><b>otext</b> string representation of the option (may include HTML)</li>
	 *     <li><b>question</b> the question to which this option belongs</li>
	 * </ul>
	 *
	 * Note that there is the opportunity for optimization here; many questions
	 * have similar answer options.
	 *
	 * Note that we do not enforce _question to be defined. This allows us to
	 * build options incrementally.
	 *
	 * @param {JSON} _jsonOption
	 * @param {Question} _question
	 * @constructor
	 */
	var Option = function Option(_jsonOption) {
	  var _question = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

	  assertJSONHasProperties(_jsonOption, 'id', 'otext');
	  optionMAP.set(_jsonOption.id, this);
	  this.id = _jsonOption.id;
	  this.otext = _jsonOption.otext;
	  this.question = _question;
	  this.toJSON = function () {
	    return {
	      id: this.id,
	      otext: this.otext
	    };
	  };
	  /**
	   * Two options are equal if their ids and text match. Note that this is not
	   * the same definition of equality as what is used in the final SurveyMan analysis.
	   * @param {*} that The object we are comparing this object to.
	   * @returns {boolean}
	   */
	  this.equals = function (that) {
	    return that instanceof Option && this.id === that.id && this.otext === that.otext;
	  };
	};

	/**
	 * Option.makeOptions creates option objects for the supplied question and ensures the
	 * ordering of the options, if necessary.
	 * @param {JSON} jsonOptions
	 * @param {Question} enclosingQuestion
	 * @param {boolean|Array} ordered
	 * @returns {Array<Option>}
	 */
	Option.makeOptions = function (jsonOptions) {
	  var enclosingQuestion = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
	  var ordered = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];

	  if (jsonOptions === undefined) {
	    log.info('No options defined for Question ' + enclosingQuestion.id + ' ( ' + enclosingQuestion.qtext + ' )');
	    return [];
	  }
	  var oList = jsonOptions.map(function (o) {
	    return new Option(o, enclosingQuestion);
	  });
	  if (Array.isArray(ordered)) {
	    var _ret = function () {
	      console.assert(ordered.length === oList.length, 'Ordered ids have a different length from the number of options.');
	      var newList = [];
	      ordered.forEach(function (oid) {
	        return newList.push(oList.filter(function (o) {
	          return o.id === oid;
	        })[0]);
	      });
	      return {
	        v: newList
	      };
	    }();

	    if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
	  }
	  return oList;
	};

	/**
	 * The Question object holds a single question.
	 * @param {JSON} _jsonQuestion
	 * @param {Question} _block
	 * @constructor
	 */
	var Question = function Question(_jsonQuestion, _block) {
	  assertJSONHasProperties(_jsonQuestion, 'id', 'qtext');
	  var id = _jsonQuestion.id,
	      branchMap = _jsonQuestion.branchMap || {},
	      freetext = _jsonQuestion.freetext,
	      qtext = _jsonQuestion.qtext,
	      options = _jsonQuestion.options,
	      correlation = _jsonQuestion.correlation,
	      jsonRandomize = _jsonQuestion.randomize,
	      ordered = _jsonQuestion.ordered,
	      exclusive = _jsonQuestion.exclusive,
	      breakoff = _jsonQuestion.breakoff;

	  questionMAP.set(id, this);
	  this.branchMap = new Map();
	  /**
	   * Returns the Option object associated with the provided option id.
	   * @param oid
	   * @returns {Option}
	   * @throws ObjectNotFoundException if this question does not contain an
	   * option with the provided id.
	   */
	  this.getOption = function (oid) {
	    for (var i = 0; i < this.options.length; i++) {
	      if (this.options[i].id === oid) {
	        return this.options[i];
	      }
	    }
	    throw new ObjectNotFoundException('Option', oid, 'question ' + this.id);
	  };
	  /**
	   * Function used to parse the provided freetext.
	   * @param freetext
	   * @returns {RegExp|boolean|string}
	   */
	  this.setFreetext = function (freetext) {
	    var reRe = new RegExp('#\{.*\}'),
	        ft = freetext;
	    if (ft === true) {
	      return true;
	    } else if (reRe.exec(ft)) {
	      return new RegExp(ft.substring(2, ft.length - 1));
	    } else return ft;
	  };
	  /**
	   * The block containing this question
	   * @type {Block}
	   */
	  this.block = _block;
	  /**
	   * String representation of the internal id of this question
	   * @type {string}
	   */
	  this.id = id;
	  /**
	   * The text to display with this question (may contain HTML).
	   * @type {string}
	   */
	  this.qtext = qtext;
	  /**
	   * Provides freetext data about this question.
	   * @type {boolean|string|RegExp}
	   */
	  this.freetext = parseBools(freetext, false) ? this.setFreetext(freetext) : Survey.freetextDefault;
	  /**
	   * Either a string or a list of strings corresponding to questions we expect
	   * to be correlated with this question.
	   * @type {string|Array<string>}
	   */
	  this.correlation = correlation;
	  // FIELDS MUST BE SENT OVER AS STRINGS
	  /**
	   * Boolean indicating whether the options in this question can be shuffled.
	   * @type {boolean}
	   */
	  if (config.debug) {
	    console.assert(typeof jsonRandomize === 'boolean' || typeof jsonRandomize === 'undefined', 'Expected boolean, got ' + (typeof jsonRandomize === 'undefined' ? 'undefined' : _typeof(jsonRandomize)));
	  }
	  this.randomizable = parseBools(jsonRandomize, Survey.randomizeDefault);
	  /**
	   * The list of options associated with this question (may be empty).
	   * @type {Array.<Option>}
	   */
	  this.options = Option.makeOptions(options, this, this.ordered);
	  /**
	   * Creates the branch map from options to blocks
	   * @type {Function}
	   */
	  this.makeBranchMap = function (question) {
	    return function () {
	      var bm = new Map();
	      // json branchMap is a map from oid to bid
	      // internal branchMap is a map from Option to Block
	      for (var k in branchMap) {
	        var o = question.getOption(k);
	        var b;
	        if (branchMap[k] === null) {
	          b = Block.NEXT_BLOCK();
	        } else {
	          b = getBlockById(branchMap[k]);
	        }
	        bm.set(o, b);
	      }
	      question.branchMap = bm;
	    };
	  }(this);
	  /**
	   *  Boolean or ordered list of option ids.
	   * @type {boolean|Array.<string>}
	   */
	  this.ordered = parseBools(ordered, Survey.orderedDefault, this);
	  /**
	   * Determines whether we should display options as radio or checkbox.
	   * @type {boolean}
	   */
	  this.exclusive = parseBools(exclusive, Survey.exclusiveDefault);
	  /**
	   * Boolean indicating whether we should allow people to submit the survey at
	   * this question.
	   * @type {boolean}
	   */
	  this.breakoff = parseBools(breakoff, Survey.breakoffDefault);
	  /**
	   * Function to randomize the contents of this question.
	   * @type {Function}
	   */
	  this.randomize = function () {
	    if (!(this.randomizable && Boolean(this.options))) return;
	    if (this.ordered) {
	      if (Math.random() < 0.5) {
	        this.options = this.options.reverse();
	      }
	    } else {
	      FYshuffle(this.options);
	    }
	  };
	  /**
	   * Returns the json representation of this question.
	   * @returns {{id: *, qtext: *, branchMap: {}, freetext: *, correlation: *, randomize: (boolean|*), options: *, ordered: *, exclusive: *, breakoff: *}}
	   */
	  this.toJSON = function () {
	    var branchMap = {};
	    for (var _ref3 in this.branchMap.entries()) {
	      var _ref2 = _slicedToArray(_ref3, 2);

	      var v = _ref2[0];
	      var k = _ref2[1];

	      branchMap[k] = v;
	    }
	    return {
	      id: this.id,
	      qtext: this.qtext,
	      branchMap: branchMap,
	      freetext: this.freetext instanceof RegExp ? this.freetext.source : this.freetext,
	      correlation: this.correlation,
	      randomize: this.randomizable,
	      options: this.options.map(function (o) {
	        return o.toJSON();
	      }),
	      ordered: this.ordered,
	      exclusive: this.exclusive,
	      breakoff: this.breakoff
	    };
	  };
	  /**
	   * Two questions are equal if their fields are equal; note that this is not
	   * the same definition of equality as in the SurveyMan analyses.
	   * @param {*} that The object to compare
	   * @returns {boolean}
	   */
	  this.equals = function (that) {
	    if (!(that instanceof Question)) return false;
	    var branchMapEqual = true;
	    var _iteratorNormalCompletion = true;
	    var _didIteratorError = false;
	    var _iteratorError = undefined;

	    try {
	      for (var _iterator = that.branchMap[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	        var _step$value = _slicedToArray(_step.value, 2);

	        var k = _step$value[0];
	        var v = _step$value[1];

	        branchMapEqual = branchMapEqual && that.branchMap.has(k) && that.branchMap.get(k).equals(v);
	        if (!branchMapEqual) break;
	      }
	    } catch (err) {
	      _didIteratorError = true;
	      _iteratorError = err;
	    } finally {
	      try {
	        if (!_iteratorNormalCompletion && _iterator.return) {
	          _iterator.return();
	        }
	      } finally {
	        if (_didIteratorError) {
	          throw _iteratorError;
	        }
	      }
	    }

	    return that instanceof Question && this.id === that.id && this.qtext === that.qtext && branchMapEqual && this.freetext === that.freetext && this.randomizable === that.randomizable && this.options.reduce(function (tv, o1) {
	      return tv && that.options.find(function (o2) {
	        return o2.equals(o1);
	      });
	    }, true) && this.ordered === that.ordered && this.exclusive === that.exclusive && this.breakoff === that.breakoff;
	  };
	  /**
	   * Adds the provided option to this question. If the question and if option ids are not
	   * semantic, the ordered field will be a list. Adds the new oid to the end of the list.
	   * That is, this function assumes that for ordered options, options will be added in order.
	   * @param {Option} option The option to add to this question.
	   */
	  this.add_option = function (option) {
	    // TODO(etosch): write unit test.
	    if (this.freetext) {
	      throw new MalformedSurveyException('Cannot add an option to a freetext question.');
	    } else {
	      this.options.push(option);
	      if (this.ordered && Array.isArray(this.ordered)) {
	        this.ordered.push(option.oid);
	      }
	    }
	  };
	  this.remove_option = function (option) {
	    var index = this.options.findIndex(function (o) {
	      return o.equals(option);
	    });
	    this.options.splice(index, 1);
	  };
	  this.clear_options = function () {
	    // TODO: write unit test.
	    this.options = [];
	    this.branchMap = new Map();
	    if (Array.isArray(this.ordered)) {
	      this.ordered = [];
	    }
	  };
	};

	/**
	 * Creates question list from the json encoding of question options.
	 * @param {JSON} _jsonQuestions
	 * @param {Block} enclosingBlock
	 * @returns {Array}
	 */
	Question.makeQuestions = function (_jsonQuestions, enclosingBlock) {
	  var i,
	      qList = [];

	  for (i = 0; i < _jsonQuestions.length; i++) {
	    var q = new Question(_jsonQuestions[i], enclosingBlock);
	    qList.push(q);
	  }
	  return qList;
	};

	/**
	 * The Block object holds other blocks or questions.
	 * @param {JSON} _jsonBlock The json version of the block, passed as the initial input.
	 * @constructor
	 */
	var Block = function Block(_jsonBlock) {
	  var _this = this;

	  assertJSONHasProperties(_jsonBlock, 'id');
	  var id = '' + _jsonBlock.id,
	      questions = _jsonBlock.questions || [],
	      jsonRandomize = _jsonBlock.randomize,
	      subblocks = _jsonBlock.subblocks || [];
	  blockMAP.set(id, this);

	  var numbersRegexp = new RegExp('[0-9]+');
	  this._idStringToArray = function (_idString) {
	    return _idString.split('.').map(function (s) {
	      return parseInt(numbersRegexp.exec(s)[0]);
	    });
	  };
	  var floatingBlockRegexp = new RegExp('(_|[a-z][a-z]*)[1-9][0-9]*');
	  var randomizableId = function randomizableId(_idString) {
	    return floatingBlockRegexp.exec(_idString.split('.').slice(-1)[0]);
	  };
	  // get the total number of 'slots' and assign indices
	  /**
	   * The user-supplied id. This will have the heirarchical/randomization semantics embedded in it.
	   * e.g.: 1._2
	   * @type string
	   */
	  this.id = id;
	  /**
	   * The idArray allows for quick lookup when comparing different blocks. For example, the block
	   * with id 1._2 has an idArray of [1, 2].
	   * @type {Array<number>}
	   */
	  this.idArray = this._idStringToArray(id);
	  /**
	   * The questions contained directly in this block, i.e., not in subblocks.
	   * @type {Array<Question>}
	   */
	  this.topLevelQuestions = Question.makeQuestions(questions, this);
	  /**
	   * The subblocks of this block.
	   * @type {Array<Block>}
	   */
	  this.subblocks = [];
	  /**
	   * Boolean indicating whether this is a floating block.
	   * @type {boolean}
	   */
	  if (config.debug) {
	    console.assert(typeof jsonRandomize === 'boolean' || typeof jsonRandomize === 'undefined', 'Expected boolean, got ' + (typeof jsonRandomize === 'undefined' ? 'undefined' : _typeof(jsonRandomize)));
	  }
	  this.randomizable = Boolean(randomizableId(this.id)) || parseBools(jsonRandomize, Block.randomizeDefault);
	  /**
	   * Returns boolean indicating whether this is a branch-all block.
	   * @returns {boolean}
	   */
	  this.isBranchAll = function () {
	    // We currently cannot randomly select a subblock.
	    if (this.subblocks.length > 0) return false;
	    // This previously checked whether the questions in the block all had NEXT pointers
	    // We have relaxed this requirement.
	    // The block is branch-all if all of the questions
	    // Since we rely on the static analyzer to do a more thorough check, for now just see
	    // if all of the branch maps are not empty.
	    if (this.topLevelQuestions.length < 2) return false;
	    var branchMapSize = this.topLevelQuestions[0].branchMap.size;
	    return branchMapSize > 0 && this.topLevelQuestions.reduce(function (tv, q) {
	      return tv && q.branchMap.size === branchMapSize;
	    }, true);
	  };
	  /**
	   * Returns boolean indicating whether this is a branch-one block.
	   * @returns {boolean}
	   */
	  this.isBranchOne = function () {
	    // Assume that we are properly formed.
	    if (this.isBranchAll()) return false;
	    if (this.topLevelQuestions.filter(function (q) {
	      return q.branchMap.size > 0;
	    }).length === 1) return true;
	    for (var i = 0; i < this.subblocks.length; i++) {
	      if (this.subblocks[i].isBranchOne()) {
	        return true;
	      }
	    }
	    return false;
	  };
	  /**
	   * Returns the question object associated with the input id.
	   * @param {string} quid The question's id.
	   * @param {boolean} deep Flag indicating whether we should search through subblocks.
	   * @param {boolean} thrownotfound Flag indicating whether we should throw an error if the question is not found.
	   * @returns {Question}
	   * @throws ObjectNotFoundException if this block does not contain a question with
	   * the input id at the top level.
	   */
	  this.getQuestion = function (quid) {
	    var deep = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];
	    var thrownotfound = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2];

	    var question = this.topLevelQuestions.find(function (q) {
	      return q.id === quid;
	    });
	    if (deep && !question) {
	      var _iteratorNormalCompletion2 = true;
	      var _didIteratorError2 = false;
	      var _iteratorError2 = undefined;

	      try {
	        for (var _iterator2 = this.subblocks[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
	          var b = _step2.value;

	          question = b.getQuestion(quid, true, false);
	          if (question) {
	            break;
	          }
	        }
	      } catch (err) {
	        _didIteratorError2 = true;
	        _iteratorError2 = err;
	      } finally {
	        try {
	          if (!_iteratorNormalCompletion2 && _iterator2.return) {
	            _iterator2.return();
	          }
	        } finally {
	          if (_didIteratorError2) {
	            throw _iteratorError2;
	          }
	        }
	      }
	    }
	    if (question || !thrownotfound) {
	      return question;
	    }
	    throw new ObjectNotFoundException('Question', quid, 'block ' + this.id);
	  };
	  /**
	   * Returns whether that follows (+1), precedes (-1), or is a sub-block (0) of this.
	   * If the ids are exactly the same, return 0; this relationship will be symmetric.
	   * @param {Block} that The block to compare.
	   * @returns {number}
	   */
	  this.idComp = function (that) {
	    if (this.id === that.id) return 0;
	    for (var i = 0; i < this.idArray.length + 1; i++) {
	      // If we have reached the end of the comparison and that block has a longer id, then
	      // that block is a subblock.
	      if (i >= that.idArray.length || i === this.idArray.length) return 0;
	      // If the block id at this's ith-level has a lower number than that's block id at
	      // the ith-level, then that precedes this. If it's greater, that follows. Otherwise,
	      // keep comparing.
	      if (this.idArray[i] < that.idArray[i]) {
	        return -1;
	      } else if (this.idArray[i] > that.idArray[i]) {
	        return 1;
	      }
	    }
	  };
	  /**
	   * Randomizes this block. Shuffles this block's questions and its subblocks appropriately.
	   */
	  this.randomize = function () {
	    var i, j;
	    var newSBlocks = this.subblocks.map(function () {
	      return -1;
	    });
	    // Randomize questions
	    FYshuffle(this.topLevelQuestions);
	    // Randomize options
	    this.topLevelQuestions.forEach(function (q) {
	      return q.randomize();
	    });
	    // If we have no subblocks, then we're done.
	    if (newSBlocks.length === 0) return;
	    // Randomize blocks
	    var stationaryBlocks = this.subblocks.filter(function (b) {
	      return !b.randomizable;
	    });
	    var nonStationaryBlocks = this.subblocks.filter(function (b) {
	      return b.randomizable;
	    });
	    var indices = this.subblocks.reduce(function (lst) {
	      return lst.concat(lst.slice(-1)[0] + 1);
	    }, [-1]).slice(1);
	    FYshuffle(indices);
	    var sample = indices.slice(0, nonStationaryBlocks.length);
	    FYshuffle(nonStationaryBlocks);

	    for (i = 0; i < sample.length; i++) {
	      // Pick the locations for where to put the non-stationary blocks
	      console.assert(nonStationaryBlocks[i] !== undefined, 'nonStationaryBlocks should never be undefined.');
	      newSBlocks[sample[i]] = nonStationaryBlocks[i];
	    }
	    for (i = 0, j = 0; i < newSBlocks.length; i++) {
	      if (newSBlocks[i] === -1) {
	        newSBlocks[i] = stationaryBlocks[j];
	        j++;
	      }
	    }
	    console.assert(j === stationaryBlocks.length, 'j should equal the number of stationary blocks: ' + j + ' vs. ' + stationaryBlocks.length);
	    this.subblocks = newSBlocks;
	    this.subblocks.forEach(function (b) {
	      return b.randomize();
	    });
	  };
	  // Added a closure to make this-semantics clear.
	  this.subblocks = function (containingBlock, subblocks) {
	    function populate(json_block, parent) {
	      var b = new Block(json_block);
	      b.parent = parent;
	      return b;
	    }

	    if (subblocks.length === 0) {
	      log.info('No subblocks in Block ' + containingBlock.id);
	      return [];
	    }
	    return subblocks.map(function (subb) {
	      return populate(subb, containingBlock);
	    });
	  }(this, subblocks);
	  console.assert(subblocks.length === this.subblocks.length, 'json subblocks must match Block object subblocks: ' + (subblocks.length + ' vs. ' + this.subblocks.length));
	  /**
	   * Returns the first question to be seen from this block.
	   * @returns {Question}
	   * @throws MalformedSurveyException if there are no questions or subblocks.
	   */
	  this.getFirstQuestion = function () {
	    if (this.topLevelQuestions.length !== 0) return this.topLevelQuestions[0];
	    if (this.subblocks.length === 0) throw new MalformedSurveyException('empty block stack ending in ' + this.id);
	    return this.subblocks[0].getFirstQuestion();
	  };
	  // Assert that the sub-blocks have the appropriate ids
	  console.assert(this.subblocks.reduce(function (tv, b) {
	    return tv && _this.idComp(b) === 0;
	  }, true), 'subblocks should all return 0 on idComp');
	  /**
	   * Returns the JSON representation of this block.
	   * @returns {{id: *, questions: *, randomize: (boolean|*), subblocks: *}}
	   */
	  this.toJSON = function () {
	    return {
	      id: this.id,
	      questions: this.topLevelQuestions.map(function (q) {
	        return q.toJSON();
	      }),
	      randomize: this.randomizable,
	      subblocks: this.subblocks.map(function (b) {
	        return b.toJSON();
	      })
	    };
	  };
	  /**
	   * Tests whether the supplied item is equivalent, in terms of Block's fields.
	   * Note that this is not the same definition of equality that SurveyMan uses
	   * for its analyses.
	   * @param {*} that The thing to compare.
	   * @returns {boolean}
	   */
	  this.equals = function (that) {
	    // TODO(etosch) : write unit test
	    return that instanceof Block && this.id === that.id && this.subblocks.reduce(function (tv, b1) {
	      return tv && that.subblocks.find(function (b2) {
	        return b1.equals(b2);
	      });
	    }, true) && this.topLevelQuestions.reduce(function (tv, q1) {
	      return tv && that.topLevelQuestions.find(function (q2) {
	        return q1.equals(q2);
	      });
	    }, true);
	  };
	  /**
	   * Returns all questions belonging to this block and its subblocks.
	   * @returns {Array<Question>}
	   */
	  this.getAllQuestions = function () {
	    var retval = [].concat(_toConsumableArray(this.topLevelQuestions));
	    this.subblocks.forEach(function (b) {
	      return b.getAllQuestions().forEach(function (q) {
	        return retval.push(q);
	      });
	    });
	    return retval;
	  };
	};

	/**
	 * Tests whether this block is a next block pointer.
	 * @param block
	 */
	Block.is_next_block = function (block) {
	  "use strict";

	  return block.id === "NEXT";
	};

	/**
	   * Gets the id of the parent block, to use for parent block lookup.
	   * @returns {string}
	   */
	Block.prototype.get_parent_id = function () {
	  var parent_arr = this.id.split('.').slice(0, -1);
	  return parent_arr.length === 0 ? "" : parent_arr.reduce(function (a, b) {
	    return a + '.' + b;
	  });
	};

	/**
	   * Adds the block provided block to this block.
	   * @param {Block} block The block to add.
	   * @param {?number} index The index at which to add this block.
	   */
	Block.prototype.add_block = function (block) {
	  var index = arguments.length <= 1 || arguments[1] === undefined ? this.subblocks.length : arguments[1];

	  var update_ids = function update_ids(parent, child) {
	    // update block's id
	    child.id = parent.id + '.' + (child.randomizable ? '_' : "") + parent.subblocks.length;
	    child.idArray = child._idStringToArray(child.id);
	    child.subblocks.forEach(function (b) {
	      return update_ids(child, b);
	    });
	  };
	  // Check whether it is valid to add this block.
	  if (this.isBranchAll()) {
	    throw new MalformedSurveyException('Cannot add subblocks to branch-all blocks.');
	  }
	  if (this.isBranchOne() && block.isBranchOne()) {
	    throw new MalformedSurveyException('Cannot add branch-one blocks as subblocks to a branch-all block');
	  }
	  if (block.get_parent_id() !== this.id) {
	    update_ids(this, block);
	  }
	  var prev_subs = this.subblocks.length;
	  this.subblocks.splice(index, 0, block);
	  block.parent = this;
	  console.assert(this.subblocks.length === prev_subs + 1);
	  //                   `Expected these subblocks ${this.subblocks.length} and prev subblocks ${prev_subs} to differ by 1.`});
	};

	/**
	 * Removes the provided block from this block's list of subblocks.
	 * @param block
	 */
	Block.prototype.remove_block = function (block) {
	  var idx = this.subblocks.find(function (subb) {
	    return subb.equals(block);
	  });
	  if (idx === -1) {
	    throw new ObjectNotFoundException('Block', block.id, 'Block' + this.id);
	  }
	  this.subblocks.splice(idx, 1);
	  block.parent = null;
	};

	/**
	   * Adds the provided question to this block.
	   * @param {Question} question Question to add to this block.
	   * @throws MalformedSurveyException if the question cannot be added.
	   */
	Block.prototype.add_question = function (question) {
	  var isBranchAll = this.subblocks.length > 0 && this.isBranchAll();
	  var isBranchOne = this.isBranchOne();
	  var isBranchNone = !isBranchAll && !isBranchOne;
	  var addingNonBranchingQuestionToNonBranchAllBlock = question.branchMap.size === 0 && !isBranchAll;
	  var addingBranchingQuestionToNonBranchingBlock = question.branchMap.size > 0 && isBranchNone;
	  var addingBranchingQuestionToSingleQuestionBranchOne = question.branchMap.size > 0 && isBranchOne && this.subblocks.length === 0 && this.topLevelQuestions.length === 1 && this.topLevelQuestions[0].branchMap.size === question.branchMap.size;
	  var addingBranchingQuestionToBranchAllBlock = question.branchMap.size > 0 && isBranchAll && this.topLevelQuestions.reduce(function (tv, q) {
	    return tv && q.branchMap.size === question.branchMap.size;
	  }, true);

	  if (addingNonBranchingQuestionToNonBranchAllBlock || addingBranchingQuestionToNonBranchingBlock || addingBranchingQuestionToSingleQuestionBranchOne || addingBranchingQuestionToBranchAllBlock) {
	    this.topLevelQuestions.push(question);
	    question.block = this;
	    return;
	  }
	  throw new MalformedSurveyException('Cannot add question with branch map size ' + question.branchMap.size + ' to block of type\n      ' + (isBranchAll ? 'BRANCH_ALL' : isBranchNone ? 'BRANCH_NONE' : 'BRANCH_ONE'));
	};

	/**
	 * Removes the provided question from this block.
	 * @param question The question to remove.
	 */
	Block.prototype.remove_question = function (question) {
	  var ctold = this.topLevelQuestions.length;
	  var idx = this.topLevelQuestions.findIndex(function (q) {
	    return q.equals(question);
	  });
	  this.topLevelQuestions.splice(idx, 1);
	  question.block = null;
	  if (config.debug) {
	    console.assert(ctold === this.topLevelQuestions.length + 1, 'Did not remove question from block.');
	  }
	};

	/**
	 * Internal tracking for generated block ids.
	 * @type {number[]}
	 * @private
	 */
	Block._blocks_ids = [1];

	/**
	 * Add a new block programmatically.
	 * @param {Block|undefined|null} parent If we are creating a subblock, we must supply the parent.
	 * @returns {Block}
	 */
	// TODO: unit test
	Block.new_block = function (parent) {
	  var idArray = [],
	      i = 0;
	  if (parent) {
	    idArray = parent.idArray;
	    console.assert(typeof parent.idArray !== 'undefined', 'parent.idArray must be defined');
	    i = parent.idArray.length;
	    if (Block._blocks_ids[i] === undefined) {
	      Block._blocks_ids[i] = 1;
	    }
	  }
	  idArray[i] = Block._blocks_ids[i];
	  Block._blocks_ids[i] += 1;
	  console.assert(typeof idArray !== 'undefined', 'idArray cannot be undefined');
	  var id = idArray.length > 1 ? idArray.reduce(function (a, b) {
	    return a + '.' + b;
	  }) : '' + idArray[0];
	  return new Block({
	    id: id,
	    questions: [],
	    subblocks: []
	  });
	};

	/**
	 * Produces the next block pointer.
	 * @returns {{id: string, randomize: Function}}
	 * @constructor
	 */
	Block.NEXT_BLOCK = function () {
	  return {
	    id: "NEXT",
	    randomize: function randomize() {}
	  };
	};

	/**
	 * Survey constructor. Takes a json survey and returns an internal survey
	 * object.
	 * @param {json} _jsonSurvey The input survey, typically generated by another program.
	 * @constructor
	 */
	var Survey = function Survey(_jsonSurvey) {
	  questionMAP.clear();
	  blockMAP.clear();
	  assertJSONHasProperties(_jsonSurvey, 'filename', 'survey');
	  var filename = _jsonSurvey.filename;
	  var survey = _jsonSurvey.survey;
	  var breakoff = _jsonSurvey.breakoff;
	  /**
	   * The path of the source file used to generate this survey; may be empty.
	   * @type {string}
	   */

	  this.filename = filename;
	  /**
	   * Boolean indicating whether breakoff is permitted for this survey.
	   * @type {boolean}
	   */
	  this.breakoff = parseBools(breakoff, Survey.breakoffDefault);
	  /**
	   * The list of top level blocks in this survey.
	   * @type {Array<survey.Block>}
	   */
	  this.topLevelBlocks = survey.map(function (jsonBlock) {
	    // console.log(jsonBlock);
	    var b = new Block(jsonBlock);
	    // console.log("new block:", b);
	    return b;
	  });
	  questionMAP.forEach(function (q) {
	    return q.makeBranchMap();
	  });
	  /**
	   * The list of all questions.
	   * @type {Array<survey.Question>}
	   */
	  this.questions = [].concat(_toConsumableArray(questionMAP.values()));
	};

	/**
	 * Returns the JSON representation of this survey.
	 *
	 * Note: we cannot just return the input json because the survey may have been mutated.
	 * @returns {{filename: *, breakoff: *, survey: *}}
	 */
	Survey.prototype.toJSON = function () {
	  return {
	    filename: this.filename,
	    breakoff: this.breakoff,
	    survey: this.topLevelBlocks.map(function (b) {
	      return b.toJSON();
	    })
	  };
	};

	/**
	 * Compares two surveys to see if they are equal, by comparing the equality of their
	 * subblocks.
	 * @param {Survey} that The survey to compare to.
	 * @returns {boolean}
	 */
	Survey.prototype.equals = function (that) {
	  var rhs = that.topLevelBlocks;
	  var lhs = this.topLevelBlocks;
	  if (!(that instanceof Survey)) return false;
	  if (lhs.length !== rhs.length) return false;
	  return lhs.reduce(function (tv, b1) {
	    return tv && rhs.find(function (b2) {
	      return b1.equals(b2);
	    });
	  }, true);
	};

	/**
	 * Searches through the survey for the option with the provided id.
	 * @param {string} oid The id of the option.
	 * @returns {Option}
	 * @throws ObjectNotFoundException if the survey does not contain any options with this id.
	 */
	Survey.prototype.get_option_by_id = function (oid) {
	  for (var i = 0; i < this.questions.length; i++) {
	    var q = this.questions[i];
	    var o = q.options.find(function (opt) {
	      return opt.id === oid;
	    }); // eslint-disable-line no-loop-func
	    if (o) return o;
	  }
	  throw new ObjectNotFoundException('Option', oid, 'current survey');
	};

	/**
	 * Returns the Question object in this survey that has the provided id.
	 * @param {string} question_id The identifier of the question of interest.
	 * @returns {Question}
	 */
	Survey.prototype.get_question_by_id = function (question_id) {
	  return this.questions.find(function (q) {
	    return q.id === question_id;
	  });
	};

	/**
	 * Returns the Block object in this survey that has the provided id.
	 * @param {string} block_id Block identifier.
	 * @returns {Block}
	 * @throws ObjectNotFoundException
	 */
	Survey.prototype.get_block_by_id = function (block_id) {
	  var notfounderr = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];

	  if (block_id === '') {
	    console.warn('Trying to get block with empty string id. Please correct.');
	    return null;
	  }
	  var find_block_by_id = function find_block_by_id(b, id) {
	    if (b.id === id) return b;
	    var _iteratorNormalCompletion3 = true;
	    var _didIteratorError3 = false;
	    var _iteratorError3 = undefined;

	    try {
	      for (var _iterator3 = b.subblocks.entries()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
	        var _step3$value = _slicedToArray(_step3.value, 2);

	        var subb = _step3$value[1];

	        var found = find_block_by_id(subb, id);
	        if (found) return found;
	      }
	    } catch (err) {
	      _didIteratorError3 = true;
	      _iteratorError3 = err;
	    } finally {
	      try {
	        if (!_iteratorNormalCompletion3 && _iterator3.return) {
	          _iterator3.return();
	        }
	      } finally {
	        if (_didIteratorError3) {
	          throw _iteratorError3;
	        }
	      }
	    }
	  };
	  var _iteratorNormalCompletion4 = true;
	  var _didIteratorError4 = false;
	  var _iteratorError4 = undefined;

	  try {
	    for (var _iterator4 = this.topLevelBlocks.entries()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
	      var _step4$value = _slicedToArray(_step4.value, 2);

	      var b = _step4$value[1];

	      var found = find_block_by_id(b, block_id);
	      if (found) return found;
	    }
	  } catch (err) {
	    _didIteratorError4 = true;
	    _iteratorError4 = err;
	  } finally {
	    try {
	      if (!_iteratorNormalCompletion4 && _iterator4.return) {
	        _iterator4.return();
	      }
	    } finally {
	      if (_didIteratorError4) {
	        throw _iteratorError4;
	      }
	    }
	  }

	  if (notfounderr) throw new ObjectNotFoundException('Block', block_id, 'current survey');
	};

	Survey.prototype._find_containing_question = function (qid, survey) {
	  //  Find the block that holds the question
	  return survey.topLevelBlocks.map(function (b) {
	    try {
	      return b.getQuestion(qid, true);
	    } catch (e) {
	      return false;
	    }
	  }).filter(function (item) {
	    return item !== false;
	  })[0];
	};

	/**
	 * Removes the provided option from the survey by searching through the survey.
	 * @param {Option} option The option to remove.
	 * @param {?Question} question The question this option belongs to.
	 */
	Survey.prototype.remove_option = function (option) {
	  var question = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

	  if (!question) {
	    question = this.questions.find(function (q) {
	      return q.options.find(function (o) {
	        return o.equals(option);
	      });
	    });
	  }
	  question.remove_option(option);
	};

	/**
	 * Adds the provided question to the provided block in this survey.
	 * @param {Question} question The question to add.
	 * @param {Block} block The block to add to.
	 */
	Survey.prototype.add_question = function (question, block) {
	  // Make sure that this survey contains the provided block.
	  var b = this.get_block_by_id(block.id);
	  console.assert(b.equals(block), 'Provided block is not equal to any known blocks in this survey.');
	  block.add_question(question);
	  this.questions.push(question);
	};

	/**
	 * Removes the provided question from the survey. If the containing block is not
	 * provided, the method will search for it.
	 * @param {Question} question The question to remove.
	 */
	Survey.prototype.remove_question = function (question) {
	  var block = question.block;
	  var block_num_questions_before = block.topLevelQuestions.length;
	  var idx = this.questions.findIndex(function (q) {
	    return q.equals(question);
	  });
	  var survey_num_questions_before = this.questions.length;
	  block.remove_question(question);
	  this.questions.splice(idx, 1);
	  if (config.debug) {
	    console.assert(block_num_questions_before === block.topLevelQuestions.length + 1, 'Did not remove question from block.');
	    console.assert(survey_num_questions_before === this.questions.length + 1, 'Did not remove question from survey.');
	  }
	};

	/**
	 * Adds the block to the survey. Mutates the survey object. If index is provided with
	 * a parent block, it will try to insert the block at the provided index in the parent
	 * block. If the block is a top-level block, it will insert at the provided index in
	 * the survey's topLevelBlock list.
	 * @param {Block} block The top-level block to add.
	 * @param {?Block} parent This block's parent. If null, it will attempt to find it.
	 * @param {?number} index The index at which to insert the provided block.
	 * the parent.
	 */
	Survey.prototype.add_block = function (block) {
	  var _this2 = this;

	  var parent = arguments.length <= 1 || arguments[1] === undefined ? this.get_block_by_id(block.get_parent_id()) : arguments[1];
	  var index = arguments.length <= 2 || arguments[2] === undefined ? parent ? parent.subblocks.length : this.topLevelBlocks.length : arguments[2];

	  if (parent) {
	    var p = this.get_block_by_id(parent.id);
	    console.assert(p.equals(parent), 'Parent block ' + parent + ' not found equal to ' + p);
	    var prev_subblocks = parent.subblocks.length;
	    parent.add_block(block, index);
	    console.assert(parent.subblocks.length === prev_subblocks + 1, "asdf1");
	  } else {
	    if (block.randomizable && block.isBranchOne()) {
	      throw new SMSurveyException('Cannot have top level blocks that are both branching and randomizable');
	    }
	    this.topLevelBlocks.splice(index, 0, block);
	  }
	  // add this block's questions to the top level survey questions
	  block.getAllQuestions().forEach(function (q) {
	    return _this2.questions.push(q);
	  });
	};

	/**
	 * Removes the block from the survey. Mutates the survey object.
	 * @param {Block} block The block to delete.
	 * @param {?Block} parent This block's parent. If null, it will attempt to find
	 * the parent.
	 */
	Survey.prototype.remove_block = function (block) {
	  var _this3 = this;

	  var parent = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];

	  if (block.idArray.length > 1) {
	    if (!parent) {
	      var parentid = block.get_parent_id();
	      parent = getBlockById(parentid);
	    }
	    var ctbefore = parent.subblocks.length;
	    parent.remove_block(block);
	    console.assert(ctbefore === parent.subblocks.length + 1, 'Did not remove Block ' + block.id + ' from Block ' + parent.id);
	  } else {
	    var i = this.topLevelBlocks.indexOf(block);
	    this.topLevelBlocks.splice(i, 1);
	  }
	  // remove this block's questions from the top level survey questions.
	  block.getAllQuestions().forEach(function (q) {
	    _this3.remove_question(q);
	  });
	};

	/**
	 * Randomizes the survey blocks and questions, as appropriate.
	 * @param {Survey} _survey
	 */
	Survey.randomize = function (_survey) {
	  var numTopLevelBlocks = _survey.topLevelBlocks.length;
	  // Select out and randomize the top level floating blocks.
	  var randomizableBlocks = _survey.topLevelBlocks.filter(function (_block) {
	    return _block.randomizable;
	  });
	  // Select out and ensure that the stationary blocks are sorted.
	  var normalBlocks = _survey.topLevelBlocks.filter(function (_block) {
	    return !_block.randomizable;
	  });
	  sortById(normalBlocks);
	  // Create a new array for the top level blocks.
	  var newTLBs = _survey.topLevelBlocks.map(function () {
	    return null;
	  });
	  // Sample indices for the floating blocks.
	  var indices = newTLBs.map(function (dontcare, i) {
	    return i;
	  });
	  FYshuffle(indices);
	  indices = indices.slice(0, randomizableBlocks.length);

	  if (config.debug) {
	    console.assert(normalBlocks.length + randomizableBlocks.length === numTopLevelBlocks, 'Num normal: ' + normalBlocks.length + '\n        Num floating: ' + randomizableBlocks.length + '\n        Num top level: ' + numTopLevelBlocks);
	    normalBlocks.forEach(function (b) {
	      return b !== undefined;
	    });
	    randomizableBlocks.forEach(function (b) {
	      return b !== undefined;
	    });
	  }

	  // Put the floating blocks where they belong
	  for (var j = 0; j < indices.length; j++) {
	    newTLBs[indices[j]] = randomizableBlocks[j];
	  }

	  // Now put the stationary blocks in order
	  var k = 0;
	  for (var _j = 0; _j < newTLBs.length; _j++) {
	    if (!Boolean(newTLBs[_j])) {
	      newTLBs[_j] = normalBlocks[k];
	      k++;
	    }
	  }
	  newTLBs.forEach(function (tlb) {
	    return tlb.randomize();
	  });

	  console.assert(newTLBs.length === numTopLevelBlocks, '#/top level blocks is invariant;' + ('expecting ' + numTopLevelBlocks + ', got ' + newTLBs.length));
	  // Reset top level blocks
	  _survey.topLevelBlocks = newTLBs;
	};

	Survey.prototype.randomize = function () {
	  Survey.randomize(this);
	};

	// 'static' fields
	Survey.exclusiveDefault = true;
	Survey.orderedDefault = false;
	Survey.randomizeDefault = true;
	Survey.freetextDefault = false;
	Survey.breakoffDefault = true;
	Block.randomizeDefault = false;

	/*****************************************************************************
	 * Interpreter submodule
	 *****************************************************************************/

	var questionSTACK = [],
	    blockSTACK = [],
	    branchDest = null;

	var flatten = function flatten(lst) {
	  console.assert(Array.isArray(lst), lst + ' is not an array');
	  if (lst.length === 0) {
	    return [];
	  } else {
	    var _lst = _toArray(lst);

	    var hd = _lst[0];

	    var tl = _lst.slice(1);

	    if (Array.isArray(hd)) {
	      return flatten(hd).concat(flatten(tl));
	    } else {
	      return [hd].concat(flatten(tl));
	    }
	  }
	};

	/**
	 *   Gets all questions for a particular block.
	 *
	 *   Either one question is a branch or all are "branch", and they're always
	 *   out of the top level block. Put the current block's questions in a global
	 *   stack that we can empty.
	 * @param _block {survey.Block} The block whose questions we want.
	 * @returns {Array} A stack of questions.
	 */
	var getAllBlockQuestions = function getAllBlockQuestions(_block) {
	  if (_block.isBranchAll()) {
	    FYshuffle(_block.topLevelQuestions);
	    return _block.topLevelQuestions[0];
	  }

	  var retval = [];
	  var indices = Array.from(_block.topLevelQuestions.concat(_block.subblocks).keys());
	  FYshuffle(indices);
	  var qindices = indices.slice(0, _block.topLevelQuestions.length);
	  var bindices = indices.filter(function (i) {
	    return qindices.find(function (j) {
	      return j === i;
	    }) === undefined;
	  });

	  var j = 0,
	      k = 0;
	  var qfind = function qfind(i) {
	    return qindices.find(function (l) {
	      return l === i;
	    });
	  };
	  var bfind = function bfind(i) {
	    return bindices.find(function (l) {
	      return l === i;
	    });
	  };
	  for (var i = 0; i < indices.length; i++) {
	    // it happens that i == indices[i]
	    if (qfind(i) !== undefined) {
	      retval.push(_block.topLevelQuestions[j]);
	      j++;
	    } else if (bfind(i) !== undefined) {
	      retval.push(getAllBlockQuestions(_block.subblocks[k]));
	      k++;
	    } else {
	      throw "Neither qindices nor bindices contain index " + i;
	    }
	  }
	  console.assert(Array.isArray(retval), retval + ' is not an array');
	  return flatten(retval);
	};

	/**
	 * Intitalizes the block and question stacks for the interpreter.
	 * @param {Array<survey.Block>} _blist The list of all top-level blocks.
	 */
	var initializeStacks = function initializeStacks(_blist) {
	  console.assert(_blist.length > 0, "Must initialize with at least one top level block.");
	  blockSTACK = _blist.map(function (b) {
	    return b;
	  });
	  questionSTACK = getAllBlockQuestions(blockSTACK.shift());
	};

	/**
	 * Loads the provided question list onto the question stack; used between
	 * blocks.
	 * @param {Array<survey.Question>} _qList The next set of questions to ask.
	 */
	var loadQuestions = function loadQuestions(_qList) {
	  questionSTACK = _qList;
	};

	/**
	 * Tests whether we have exhausted the questions for this block.
	 * @returns {boolean}
	 */
	var isQuestionStackEmpty = function isQuestionStackEmpty() {
	  return questionSTACK.length === 0;
	};

	/**
	 * Tests whether we have exhaused the blocks in this survey.
	 * @returns {boolean}
	 */
	var isBlockStackEmpty = function isBlockStackEmpty() {
	  return blockSTACK.length === 0;
	};

	/**
	 * Returns the next question in the survey. If the question stack is empty,
	 * this returns undefined.
	 * @returns {survey.Question}
	 */
	var nextQuestion = function nextQuestion() {
	  return questionSTACK.shift();
	};

	/**
	/**
	 * Returns the next block in the survey. If the previous block was a branch-one
	 * block, pops off stationary blocks until it either reaches a floating block or
	 * the branch destination. If it finds the branch destination first, it resets
	 * the branchDest pointer.
	 * @returns {survey.Block}
	 */
	var nextBlock = function nextBlock() {
	  var head;
	  if (branchDest && !Block.is_next_block(branchDest)) {
	    while (!isBlockStackEmpty()) {
	      head = blockSTACK.shift();
	      if (head === branchDest) {
	        blockSTACK.unshift(head);
	        branchDest = null;
	        break;
	      } else if (head.randomizable) {
	        blockSTACK.unshift(head);
	        break;
	      }
	    }
	  }
	  console.assert(isQuestionStackEmpty());
	  loadQuestions(getAllBlockQuestions(blockSTACK.shift()));
	  return head;
	};

	/**
	 * Checks whether the provided question has a "true" branch target for the
	 * provided option. Returns the apporpriate question.
	 * @param {survey.Question} q
	 * @param {survey.Option} o
	 * @returns {survey.Question}
	 */
	var handleBranching = function handleBranching(q, o) {
	  if (q.branchMap.has(o)) {
	    var bdest = q.branchMap.get(o);
	    if (Block.is_next_block(bdest)) {
	      branchDest = blockSTACK[0];
	    } else {
	      branchDest = bdest;
	    }
	  }
	  if (isQuestionStackEmpty()) nextBlock();
	  return nextQuestion();
	};

	/**
	 * Returns the next question. If the block stack is empty, refreshes it.
	 * @returns {survey.Question}
	 */
	var nextSequential = function nextSequential() {
	  if (isQuestionStackEmpty()) nextBlock();
	  return nextQuestion();
	};

	/*****************************************************************************
	 * top-level surveyman module
	 *****************************************************************************/

	var _gensym = function (counter) {
	  return function () {
	    var prefix = arguments.length <= 0 || arguments[0] === undefined ? "" : arguments[0];

	    return '' + prefix + counter++;
	  };
	}(0);

	var survey_init = function survey_init(jsonSurvey) {
	  console.assert(jsonSurvey !== undefined);
	  var survey = new Survey(jsonSurvey);
	  Survey.randomize(survey);
	  console.assert(survey.topLevelBlocks.length > 0, "Must have at least one top level block.");
	  return survey;
	};

	/**
	 * Contains top-level calls for use by external programs, e.g. the survey construction GUI.
	 * @namespace surveyman
	 * @type {{survey: {_parseBools: Function, _sortById: Function, _global_reset: Function, init: Function, getOptionById: Function, getQuestionById: Function, getBlockById: Function, Survey: Function, Block: Function, Question: Function, Option: Function}, interpreter: {init: Function, isQuestionStackEmpty: Function, isBlockStackEmpty: Function, nextBlock: Function, nextQuestion: Function, handleBranching: Function, nextSequential: Function}}}
	 */
	module.exports = {
	  /**
	   * @namespace survey
	   * @type {{_parseBools: Function, _sortById: Function, _global_reset: Function, init: Function, getOptionById: Function, getQuestionById: Function, getBlockById: Function, Survey: Function, Block: Function, Question: Function, Option: Function}}
	   */
	  survey: {
	    _parseBools: parseBools,
	    _sortById: sortById,
	    _global_reset: global_reset,
	    init: survey_init,
	    getOptionById: getOptionById,
	    getQuestionById: getQuestionById,
	    getBlockById: getBlockById,
	    Survey: Survey,
	    Block: Block,
	    Question: Question,
	    Option: Option
	  },
	  /**
	   * @namespace interpreter
	   * @type {{init: Function, isQuestionStackEmpty: Function, isBlockStackEmpty: Function, nextBlock: Function, nextQuestion: Function, handleBranching: Function, nextSequential: Function}}
	   */
	  interpreter: {
	    /**
	     * Initializes the interpreter
	     * @param jsonSurvey The json representation of the survey.
	     * @returns {Survey} The survey object.
	     */
	    init: function init(jsonSurvey) {
	      var survey = survey_init(jsonSurvey);
	      console.assert(survey.topLevelBlocks.length > 0, "Must have at least one top level block.");
	      initializeStacks(survey.topLevelBlocks);
	      return survey;
	    },
	    _branchDest: branchDest,
	    _flatten: flatten,
	    isQuestionStackEmpty: isQuestionStackEmpty,
	    isBlockStackEmpty: isBlockStackEmpty,
	    nextBlock: nextBlock,
	    nextQuestion: nextQuestion,
	    handleBranching: handleBranching,
	    nextSequential: nextSequential
	  },
	  _gensym: _gensym,
	  /**
	   * Top-level call to create a new survey.
	   * @returns {survey.Survey}
	   */
	  new_survey: function new_survey() {
	    return new Survey({
	      filename: "temp_file_name.json",
	      breakoff: Survey.breakoffDefault,
	      survey: [this.new_block().toJSON()]
	    });
	  },

	  /**
	   * Top-level call to copy the input survey to a new survey.
	   * Quick and dirty approach -- converts to JSON and re-parses.
	   * @param survey
	   * @returns {Survey}
	   */
	  copy_survey: function copy_survey(survey) {
	    var s = JSON.stringify(survey.toJSON());
	    return new Survey(JSON.parse(s));
	  },
	  /**
	   * Top-level call to create a new empty block.
	   * @param {string} bid The block id.
	   * @returns {Block}
	   */
	  new_block: Block.new_block,
	  /**
	   * Top-level call to copy a block. Done by converting to JSON and copying.
	   * This is the quick and dirty approach to copying.
	   * @param {Block} block The block to copy.
	   * @param {boolean} new_id  Flag indicating whether we should create a new id for this block.
	   * @returns {Block}
	   */
	  copy_block: function copy_block(block) {
	    var new_id = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

	    var b = new Block(block.toJSON());
	    if (new_id) {
	      b.id = Block.new_block(block.parent).id;
	    }
	    return b;
	  },
	  /**
	   * Adds a block to the top level of the survey.
	   * @param {Survey} survey The survey to add the block to.
	   * @param {Block} block The block to add.
	   * @param {?Block} parent_block The parent block to add this block to.
	   * @param {?boolean} mutate Flag indicating whether we should mutate the survey provided or return an updated copy.
	   * @param {number} index Index at which to add the the block in its containing parent.
	   * @returns {?Survey}
	   */
	  add_block: function add_block(survey, block) {
	    var parent_block = arguments.length <= 2 || arguments[2] === undefined ? survey.get_block_by_id(block.get_parent_id()) : arguments[2];
	    var mutate = arguments.length <= 3 || arguments[3] === undefined ? true : arguments[3];
	    var index = arguments.length <= 4 || arguments[4] === undefined ? parent_block ? parent_block.subblocks.length : survey.topLevelBlocks.length : arguments[4];

	    if (mutate) {
	      survey.add_block(block, parent_block, index);
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      var b = this.copy_block(block);
	      var p = s.get_block_by_id(parent_block ? parent_block.id : '');
	      s.add_block(b, p, index);
	      return s;
	    }
	  },
	  /**
	   * Top-level call to remove a block from the Survey.
	   * @param {Block} block The block to remove.
	   * @param {Survey} survey The survey to remove the block from.
	   * @param {boolean} mutate Flag indicating whether we should mutate the survey,
	   * or return a new survey with this block removed.
	   * @returns {?Survey}
	   */
	  remove_block: function remove_block(block, survey) {
	    var mutate = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2];

	    if (mutate) {
	      survey.remove_block(block);
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      try {
	        var b = s.get_block_by_id(block.id);
	        s.remove_block(b);
	        return s;
	      } catch (e) {
	        //console.log(s);
	        throw e;
	      }
	    }
	  },
	  /**
	   * Top-level call to create a new Question.
	   * @param {string} surface_text The text to be displayed for this question. May include HTML.
	   * @param {string} qid The question id.
	   * @returns {Question}
	   */
	  new_question: function new_question(surface_text) {
	    var qid = arguments.length <= 1 || arguments[1] === undefined ? _gensym("question") : arguments[1];

	    return new Question({
	      id: qid,
	      qtext: surface_text
	    }, null);
	  },
	  /**
	   * Top-level call to copy a question.
	   * Done by converting to JSON and re-parsing.
	   * @param {Question} question
	   * @param {boolean} new_id Flag indicating whether we should generate a new id for the copied object.
	   * @returns {Question}
	   */
	  copy_question: function copy_question(question) {
	    var new_id = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1];

	    var new_question = new Question(question.toJSON());
	    if (new_id) {
	      new_question.id = _gensym('q');
	    }
	    return new_question;
	  },
	  /**
	   * Top-level call to add a question to a block.
	   * @param {Question} question The question we want to add.
	   * @param {Block} block The block we want to add the question to.
	   * @param {?Survey} survey The survey that contains the question and the block
	   * @param {boolean } mutate Boolean indicating whether we should mutate the survey or return
	   * a new survey.
	   * @returns {?Survey}
	   */
	  add_question: function add_question(question, block, survey) {
	    var mutate = arguments.length <= 3 || arguments[3] === undefined ? true : arguments[3];

	    if (mutate) {
	      block.add_question(question);
	      survey.questions.push(question);
	      if (config.debug) {
	        console.assert(question.block === block);
	      }
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      var q = this.copy_question(question);
	      // Get the block in our new survey that matches the input block's id.
	      var b = s.get_block_by_id(block.id);
	      s.add_question(q, b);
	      return s;
	    }
	  },
	  /**
	   * Removes the question from the provided survey.
	   * @param {Question} question The question to remove.
	   * @param {Survey} survey The survey to remove the question from.
	   * @param {boolean} mutate Flag inidicating whether we should mutate the
	   * survey or return a new one.
	   * @returns {?Survey}
	   */
	  remove_question: function remove_question(question, survey) {
	    var mutate = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2];

	    if (mutate) {
	      survey.remove_question(question);
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      var q = s.get_question_by_id(question.id);
	      s.remove_question(q);
	      return s;
	    }
	  },
	  /**
	   * Top-level call to create a new Option.
	   * @param {string} surface_text The text to be displayed to the user.
	   * @param {string} oid The option id.
	   * @returns {Option}
	   */
	  new_option: function new_option(surface_text) {
	    var oid = arguments.length <= 1 || arguments[1] === undefined ? _gensym("option") : arguments[1];

	    return new Option({
	      id: oid,
	      otext: surface_text
	    });
	  },
	  /**
	   * Top-level call to add an option to a question.
	   * @param {Question} question The question to add the option to.
	   * @param {Option} option The option to add to the input question.
	   * @param {Survey} survey The survey that this question belongs to.
	   * @param {boolean} mutate Flag indicating whether we should mutate the survey
	   * provided, or return a new survey.
	   * @returns {?Survey}
	   */
	  add_option: function add_option(option, question, survey) {
	    var mutate = arguments.length <= 3 || arguments[3] === undefined ? true : arguments[3];

	    if (mutate) {
	      question.add_option(option);
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      var q = s.questions.find(function (q) {
	        return q.id === question.id;
	      });
	      q.add_option(option);
	      return s;
	    }
	  },
	  /**
	   * Removes the option from the provided survey
	   * @param {Option} option The option to remove.
	   * @param {Survey} survey The survey to remove the option from.
	   * @param {?Question} question The question to remove the option from.
	   * @param {boolean} mutate Flag indicating whether the survey should be
	   * mutated or if a new survey should be returned.
	   * @returns {?Survey}
	   */
	  remove_option: function remove_option(option, survey) {
	    var question = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
	    var mutate = arguments.length <= 3 || arguments[3] === undefined ? true : arguments[3];

	    if (mutate) {
	      survey.remove_option(option, question, survey);
	      return null;
	    } else {
	      var s = this.copy_survey(survey);
	      s.remove_option(option);
	      return s;
	    }
	  }
	};

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(global, process) {'use strict';var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol?"symbol":typeof obj;};/*!
	  * https://github.com/paulmillr/es6-shim
	  * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)
	  *   and contributors,  MIT License
	  * es6-shim: v0.35.1
	  * see https://github.com/paulmillr/es6-shim/blob/0.35.1/LICENSE
	  * Details and documentation:
	  * https://github.com/paulmillr/es6-shim/
	  */// UMD (Universal Module Definition)
	// see https://github.com/umdjs/umd/blob/master/returnExports.js
	(function(root,factory){/*global define, module, exports */if(true){// AMD. Register as an anonymous module.
	!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));}else if((typeof exports==='undefined'?'undefined':_typeof(exports))==='object'){// Node. Does not work with strict CommonJS, but
	// only CommonJS-like environments that support module.exports,
	// like Node.
	module.exports=factory();}else{// Browser globals (root is window)
	root.returnExports=factory();}})(undefined,function(){'use strict';var _apply=Function.call.bind(Function.apply);var _call=Function.call.bind(Function.call);var isArray=Array.isArray;var keys=Object.keys;var not=function notThunker(func){return function notThunk(){return!_apply(func,this,arguments);};};var throwsError=function throwsError(func){try{func();return false;}catch(e){return true;}};var valueOrFalseIfThrows=function valueOrFalseIfThrows(func){try{return func();}catch(e){return false;}};var isCallableWithoutNew=not(throwsError);var arePropertyDescriptorsSupported=function arePropertyDescriptorsSupported(){// if Object.defineProperty exists but throws, it's IE 8
	return!throwsError(function(){Object.defineProperty({},'x',{get:function get(){}});});};var supportsDescriptors=!!Object.defineProperty&&arePropertyDescriptorsSupported();var functionsHaveNames=function foo(){}.name==='foo';// eslint-disable-line no-extra-parens
	var _forEach=Function.call.bind(Array.prototype.forEach);var _reduce=Function.call.bind(Array.prototype.reduce);var _filter=Function.call.bind(Array.prototype.filter);var _some=Function.call.bind(Array.prototype.some);var defineProperty=function defineProperty(object,name,value,force){if(!force&&name in object){return;}if(supportsDescriptors){Object.defineProperty(object,name,{configurable:true,enumerable:false,writable:true,value:value});}else{object[name]=value;}};// Define configurable, writable and non-enumerable props
	// if they don’t exist.
	var defineProperties=function defineProperties(object,map,forceOverride){_forEach(keys(map),function(name){var method=map[name];defineProperty(object,name,method,!!forceOverride);});};var _toString=Function.call.bind(Object.prototype.toString);var isCallable= false?function IsCallableSlow(x){// Some old browsers (IE, FF) say that typeof /abc/ === 'function'
	return typeof x==='function'&&_toString(x)==='[object Function]';}:function IsCallableFast(x){return typeof x==='function';};var Value={getter:function getter(object,name,_getter){if(!supportsDescriptors){throw new TypeError('getters require true ES5 support');}Object.defineProperty(object,name,{configurable:true,enumerable:false,get:_getter});},proxy:function proxy(originalObject,key,targetObject){if(!supportsDescriptors){throw new TypeError('getters require true ES5 support');}var originalDescriptor=Object.getOwnPropertyDescriptor(originalObject,key);Object.defineProperty(targetObject,key,{configurable:originalDescriptor.configurable,enumerable:originalDescriptor.enumerable,get:function getKey(){return originalObject[key];},set:function setKey(value){originalObject[key]=value;}});},redefine:function redefine(object,property,newValue){if(supportsDescriptors){var descriptor=Object.getOwnPropertyDescriptor(object,property);descriptor.value=newValue;Object.defineProperty(object,property,descriptor);}else{object[property]=newValue;}},defineByDescriptor:function defineByDescriptor(object,property,descriptor){if(supportsDescriptors){Object.defineProperty(object,property,descriptor);}else if('value'in descriptor){object[property]=descriptor.value;}},preserveToString:function preserveToString(target,source){if(source&&isCallable(source.toString)){defineProperty(target,'toString',source.toString.bind(source),true);}}};// Simple shim for Object.create on ES3 browsers
	// (unlike real shim, no attempt to support `prototype === null`)
	var create=Object.create||function(prototype,properties){var Prototype=function Prototype(){};Prototype.prototype=prototype;var object=new Prototype();if(typeof properties!=='undefined'){keys(properties).forEach(function(key){Value.defineByDescriptor(object,key,properties[key]);});}return object;};var supportsSubclassing=function supportsSubclassing(C,f){if(!Object.setPrototypeOf){return false;/* skip test on IE < 11 */}return valueOrFalseIfThrows(function(){var Sub=function Subclass(arg){var o=new C(arg);Object.setPrototypeOf(o,Subclass.prototype);return o;};Object.setPrototypeOf(Sub,C);Sub.prototype=create(C.prototype,{constructor:{value:Sub}});return f(Sub);});};var getGlobal=function getGlobal(){/* global self, window, global */// the only reliable means to get the global object is
	// `Function('return this')()`
	// However, this causes CSP violations in Chrome apps.
	if(typeof self!=='undefined'){return self;}if(typeof window!=='undefined'){return window;}if(typeof global!=='undefined'){return global;}throw new Error('unable to locate global object');};var globals=getGlobal();var globalIsFinite=globals.isFinite;var _indexOf=Function.call.bind(String.prototype.indexOf);var _arrayIndexOfApply=Function.apply.bind(Array.prototype.indexOf);var _concat=Function.call.bind(Array.prototype.concat);// var _sort = Function.call.bind(Array.prototype.sort);
	var _strSlice=Function.call.bind(String.prototype.slice);var _push=Function.call.bind(Array.prototype.push);var _pushApply=Function.apply.bind(Array.prototype.push);var _shift=Function.call.bind(Array.prototype.shift);var _max=Math.max;var _min=Math.min;var _floor=Math.floor;var _abs=Math.abs;var _exp=Math.exp;var _log=Math.log;var _sqrt=Math.sqrt;var _hasOwnProperty=Function.call.bind(Object.prototype.hasOwnProperty);var ArrayIterator;// make our implementation private
	var noop=function noop(){};var _Symbol=globals.Symbol||{};var symbolSpecies=_Symbol.species||'@@species';var numberIsNaN=Number.isNaN||function isNaN(value){// NaN !== NaN, but they are identical.
	// NaNs are the only non-reflexive value, i.e., if x !== x,
	// then x is NaN.
	// isNaN is broken: it converts its argument to number, so
	// isNaN('foo') => true
	return value!==value;};var numberIsFinite=Number.isFinite||function isFinite(value){return typeof value==='number'&&globalIsFinite(value);};var _sign=isCallable(Math.sign)?Math.sign:function sign(value){var number=Number(value);if(number===0){return number;}if(numberIsNaN(number)){return number;}return number<0?-1:1;};// taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js
	// can be replaced with require('is-arguments') if we ever use a build process instead
	var isStandardArguments=function isArguments(value){return _toString(value)==='[object Arguments]';};var isLegacyArguments=function isArguments(value){return value!==null&&(typeof value==='undefined'?'undefined':_typeof(value))==='object'&&typeof value.length==='number'&&value.length>=0&&_toString(value)!=='[object Array]'&&_toString(value.callee)==='[object Function]';};var isArguments=isStandardArguments(arguments)?isStandardArguments:isLegacyArguments;var Type={primitive:function primitive(x){return x===null||typeof x!=='function'&&(typeof x==='undefined'?'undefined':_typeof(x))!=='object';},string:function string(x){return _toString(x)==='[object String]';},regex:function regex(x){return _toString(x)==='[object RegExp]';},symbol:function symbol(x){return typeof globals.Symbol==='function'&&(typeof x==='undefined'?'undefined':_typeof(x))==='symbol';}};var overrideNative=function overrideNative(object,property,replacement){var original=object[property];defineProperty(object,property,replacement,true);Value.preserveToString(object[property],original);};var hasSymbols=typeof _Symbol==='function'&&typeof _Symbol['for']==='function'&&Type.symbol(_Symbol());// This is a private name in the es6 spec, equal to '[Symbol.iterator]'
	// we're going to use an arbitrary _-prefixed name to make our shims
	// work properly with each other, even though we don't have full Iterator
	// support.  That is, `Array.from(map.keys())` will work, but we don't
	// pretend to export a "real" Iterator interface.
	var $iterator$=Type.symbol(_Symbol.iterator)?_Symbol.iterator:'_es6-shim iterator_';// Firefox ships a partial implementation using the name @@iterator.
	// https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14
	// So use that name if we detect it.
	if(globals.Set&&typeof new globals.Set()['@@iterator']==='function'){$iterator$='@@iterator';}// Reflect
	if(!globals.Reflect){defineProperty(globals,'Reflect',{},true);}var Reflect=globals.Reflect;var $String=String;var ES={// http://www.ecma-international.org/ecma-262/6.0/#sec-call
	Call:function Call(F,V){var args=arguments.length>2?arguments[2]:[];if(!ES.IsCallable(F)){throw new TypeError(F+' is not a function');}return _apply(F,V,args);},RequireObjectCoercible:function RequireObjectCoercible(x,optMessage){/* jshint eqnull:true */if(x==null){throw new TypeError(optMessage||'Cannot call method on '+x);}return x;},// This might miss the "(non-standard exotic and does not implement
	// [[Call]])" case from
	// http://www.ecma-international.org/ecma-262/6.0/#sec-typeof-operator-runtime-semantics-evaluation
	// but we can't find any evidence these objects exist in practice.
	// If we find some in the future, you could test `Object(x) === x`,
	// which is reliable according to
	// http://www.ecma-international.org/ecma-262/6.0/#sec-toobject
	// but is not well optimized by runtimes and creates an object
	// whenever it returns false, and thus is very slow.
	TypeIsObject:function TypeIsObject(x){if(x===void 0||x===null||x===true||x===false){return false;}return typeof x==='function'||(typeof x==='undefined'?'undefined':_typeof(x))==='object';},ToObject:function ToObject(o,optMessage){return Object(ES.RequireObjectCoercible(o,optMessage));},IsCallable:isCallable,IsConstructor:function IsConstructor(x){// We can't tell callables from constructors in ES5
	return ES.IsCallable(x);},ToInt32:function ToInt32(x){return ES.ToNumber(x)>>0;},ToUint32:function ToUint32(x){return ES.ToNumber(x)>>>0;},ToNumber:function ToNumber(value){if(_toString(value)==='[object Symbol]'){throw new TypeError('Cannot convert a Symbol value to a number');}return+value;},ToInteger:function ToInteger(value){var number=ES.ToNumber(value);if(numberIsNaN(number)){return 0;}if(number===0||!numberIsFinite(number)){return number;}return(number>0?1:-1)*_floor(_abs(number));},ToLength:function ToLength(value){var len=ES.ToInteger(value);if(len<=0){return 0;}// includes converting -0 to +0
	if(len>Number.MAX_SAFE_INTEGER){return Number.MAX_SAFE_INTEGER;}return len;},SameValue:function SameValue(a,b){if(a===b){// 0 === -0, but they are not identical.
	if(a===0){return 1/a===1/b;}return true;}return numberIsNaN(a)&&numberIsNaN(b);},SameValueZero:function SameValueZero(a,b){// same as SameValue except for SameValueZero(+0, -0) == true
	return a===b||numberIsNaN(a)&&numberIsNaN(b);},IsIterable:function IsIterable(o){return ES.TypeIsObject(o)&&(typeof o[$iterator$]!=='undefined'||isArguments(o));},GetIterator:function GetIterator(o){if(isArguments(o)){// special case support for `arguments`
	return new ArrayIterator(o,'value');}var itFn=ES.GetMethod(o,$iterator$);if(!ES.IsCallable(itFn)){// Better diagnostics if itFn is null or undefined
	throw new TypeError('value is not an iterable');}var it=ES.Call(itFn,o);if(!ES.TypeIsObject(it)){throw new TypeError('bad iterator');}return it;},GetMethod:function GetMethod(o,p){var func=ES.ToObject(o)[p];if(func===void 0||func===null){return void 0;}if(!ES.IsCallable(func)){throw new TypeError('Method not callable: '+p);}return func;},IteratorComplete:function IteratorComplete(iterResult){return!!iterResult.done;},IteratorClose:function IteratorClose(iterator,completionIsThrow){var returnMethod=ES.GetMethod(iterator,'return');if(returnMethod===void 0){return;}var innerResult,innerException;try{innerResult=ES.Call(returnMethod,iterator);}catch(e){innerException=e;}if(completionIsThrow){return;}if(innerException){throw innerException;}if(!ES.TypeIsObject(innerResult)){throw new TypeError("Iterator's return method returned a non-object.");}},IteratorNext:function IteratorNext(it){var result=arguments.length>1?it.next(arguments[1]):it.next();if(!ES.TypeIsObject(result)){throw new TypeError('bad iterator');}return result;},IteratorStep:function IteratorStep(it){var result=ES.IteratorNext(it);var done=ES.IteratorComplete(result);return done?false:result;},Construct:function Construct(C,args,newTarget,isES6internal){var target=typeof newTarget==='undefined'?C:newTarget;if(!isES6internal&&Reflect.construct){// Try to use Reflect.construct if available
	return Reflect.construct(C,args,target);}// OK, we have to fake it.  This will only work if the
	// C.[[ConstructorKind]] == "base" -- but that's the only
	// kind we can make in ES5 code anyway.
	// OrdinaryCreateFromConstructor(target, "%ObjectPrototype%")
	var proto=target.prototype;if(!ES.TypeIsObject(proto)){proto=Object.prototype;}var obj=create(proto);// Call the constructor.
	var result=ES.Call(C,obj,args);return ES.TypeIsObject(result)?result:obj;},SpeciesConstructor:function SpeciesConstructor(O,defaultConstructor){var C=O.constructor;if(C===void 0){return defaultConstructor;}if(!ES.TypeIsObject(C)){throw new TypeError('Bad constructor');}var S=C[symbolSpecies];if(S===void 0||S===null){return defaultConstructor;}if(!ES.IsConstructor(S)){throw new TypeError('Bad @@species');}return S;},CreateHTML:function CreateHTML(string,tag,attribute,value){var S=ES.ToString(string);var p1='<'+tag;if(attribute!==''){var V=ES.ToString(value);var escapedV=V.replace(/"/g,'&quot;');p1+=' '+attribute+'="'+escapedV+'"';}var p2=p1+'>';var p3=p2+S;return p3+'</'+tag+'>';},IsRegExp:function IsRegExp(argument){if(!ES.TypeIsObject(argument)){return false;}var isRegExp=argument[_Symbol.match];if(typeof isRegExp!=='undefined'){return!!isRegExp;}return Type.regex(argument);},ToString:function ToString(string){return $String(string);}};// Well-known Symbol shims
	if(supportsDescriptors&&hasSymbols){var defineWellKnownSymbol=function defineWellKnownSymbol(name){if(Type.symbol(_Symbol[name])){return _Symbol[name];}var sym=_Symbol['for']('Symbol.'+name);Object.defineProperty(_Symbol,name,{configurable:false,enumerable:false,writable:false,value:sym});return sym;};if(!Type.symbol(_Symbol.search)){var symbolSearch=defineWellKnownSymbol('search');var originalSearch=String.prototype.search;defineProperty(RegExp.prototype,symbolSearch,function search(string){return ES.Call(originalSearch,string,[this]);});var searchShim=function search(regexp){var O=ES.RequireObjectCoercible(this);if(regexp!==null&&typeof regexp!=='undefined'){var searcher=ES.GetMethod(regexp,symbolSearch);if(typeof searcher!=='undefined'){return ES.Call(searcher,regexp,[O]);}}return ES.Call(originalSearch,O,[ES.ToString(regexp)]);};overrideNative(String.prototype,'search',searchShim);}if(!Type.symbol(_Symbol.replace)){var symbolReplace=defineWellKnownSymbol('replace');var originalReplace=String.prototype.replace;defineProperty(RegExp.prototype,symbolReplace,function replace(string,replaceValue){return ES.Call(originalReplace,string,[this,replaceValue]);});var replaceShim=function replace(searchValue,replaceValue){var O=ES.RequireObjectCoercible(this);if(searchValue!==null&&typeof searchValue!=='undefined'){var replacer=ES.GetMethod(searchValue,symbolReplace);if(typeof replacer!=='undefined'){return ES.Call(replacer,searchValue,[O,replaceValue]);}}return ES.Call(originalReplace,O,[ES.ToString(searchValue),replaceValue]);};overrideNative(String.prototype,'replace',replaceShim);}if(!Type.symbol(_Symbol.split)){var symbolSplit=defineWellKnownSymbol('split');var originalSplit=String.prototype.split;defineProperty(RegExp.prototype,symbolSplit,function split(string,limit){return ES.Call(originalSplit,string,[this,limit]);});var splitShim=function split(separator,limit){var O=ES.RequireObjectCoercible(this);if(separator!==null&&typeof separator!=='undefined'){var splitter=ES.GetMethod(separator,symbolSplit);if(typeof splitter!=='undefined'){return ES.Call(splitter,separator,[O,limit]);}}return ES.Call(originalSplit,O,[ES.ToString(separator),limit]);};overrideNative(String.prototype,'split',splitShim);}var symbolMatchExists=Type.symbol(_Symbol.match);var stringMatchIgnoresSymbolMatch=symbolMatchExists&&function(){// Firefox 41, through Nightly 45 has Symbol.match, but String#match ignores it.
	// Firefox 40 and below have Symbol.match but String#match works fine.
	var o={};o[_Symbol.match]=function(){return 42;};return'a'.match(o)!==42;}();if(!symbolMatchExists||stringMatchIgnoresSymbolMatch){var symbolMatch=defineWellKnownSymbol('match');var originalMatch=String.prototype.match;defineProperty(RegExp.prototype,symbolMatch,function match(string){return ES.Call(originalMatch,string,[this]);});var matchShim=function match(regexp){var O=ES.RequireObjectCoercible(this);if(regexp!==null&&typeof regexp!=='undefined'){var matcher=ES.GetMethod(regexp,symbolMatch);if(typeof matcher!=='undefined'){return ES.Call(matcher,regexp,[O]);}}return ES.Call(originalMatch,O,[ES.ToString(regexp)]);};overrideNative(String.prototype,'match',matchShim);}}var wrapConstructor=function wrapConstructor(original,replacement,keysToSkip){Value.preserveToString(replacement,original);if(Object.setPrototypeOf){// sets up proper prototype chain where possible
	Object.setPrototypeOf(original,replacement);}if(supportsDescriptors){_forEach(Object.getOwnPropertyNames(original),function(key){if(key in noop||keysToSkip[key]){return;}Value.proxy(original,key,replacement);});}else{_forEach(Object.keys(original),function(key){if(key in noop||keysToSkip[key]){return;}replacement[key]=original[key];});}replacement.prototype=original.prototype;Value.redefine(original.prototype,'constructor',replacement);};var defaultSpeciesGetter=function defaultSpeciesGetter(){return this;};var addDefaultSpecies=function addDefaultSpecies(C){if(supportsDescriptors&&!_hasOwnProperty(C,symbolSpecies)){Value.getter(C,symbolSpecies,defaultSpeciesGetter);}};var addIterator=function addIterator(prototype,impl){var implementation=impl||function iterator(){return this;};defineProperty(prototype,$iterator$,implementation);if(!prototype[$iterator$]&&Type.symbol($iterator$)){// implementations are buggy when $iterator$ is a Symbol
	prototype[$iterator$]=implementation;}};var createDataProperty=function createDataProperty(object,name,value){if(supportsDescriptors){Object.defineProperty(object,name,{configurable:true,enumerable:true,writable:true,value:value});}else{object[name]=value;}};var createDataPropertyOrThrow=function createDataPropertyOrThrow(object,name,value){createDataProperty(object,name,value);if(!ES.SameValue(object[name],value)){throw new TypeError('property is nonconfigurable');}};var emulateES6construct=function emulateES6construct(o,defaultNewTarget,defaultProto,slots){// This is an es5 approximation to es6 construct semantics.  in es6,
	// 'new Foo' invokes Foo.[[Construct]] which (for almost all objects)
	// just sets the internal variable NewTarget (in es6 syntax `new.target`)
	// to Foo and then returns Foo().
	// Many ES6 object then have constructors of the form:
	// 1. If NewTarget is undefined, throw a TypeError exception
	// 2. Let xxx by OrdinaryCreateFromConstructor(NewTarget, yyy, zzz)
	// So we're going to emulate those first two steps.
	if(!ES.TypeIsObject(o)){throw new TypeError('Constructor requires `new`: '+defaultNewTarget.name);}var proto=defaultNewTarget.prototype;if(!ES.TypeIsObject(proto)){proto=defaultProto;}var obj=create(proto);for(var name in slots){if(_hasOwnProperty(slots,name)){var value=slots[name];defineProperty(obj,name,value,true);}}return obj;};// Firefox 31 reports this function's length as 0
	// https://bugzilla.mozilla.org/show_bug.cgi?id=1062484
	if(String.fromCodePoint&&String.fromCodePoint.length!==1){var originalFromCodePoint=String.fromCodePoint;overrideNative(String,'fromCodePoint',function fromCodePoint(codePoints){return ES.Call(originalFromCodePoint,this,arguments);});}var StringShims={fromCodePoint:function fromCodePoint(codePoints){var result=[];var next;for(var i=0,length=arguments.length;i<length;i++){next=Number(arguments[i]);if(!ES.SameValue(next,ES.ToInteger(next))||next<0||next>0x10FFFF){throw new RangeError('Invalid code point '+next);}if(next<0x10000){_push(result,String.fromCharCode(next));}else{next-=0x10000;_push(result,String.fromCharCode((next>>10)+0xD800));_push(result,String.fromCharCode(next%0x400+0xDC00));}}return result.join('');},raw:function raw(callSite){var cooked=ES.ToObject(callSite,'bad callSite');var rawString=ES.ToObject(cooked.raw,'bad raw value');var len=rawString.length;var literalsegments=ES.ToLength(len);if(literalsegments<=0){return'';}var stringElements=[];var nextIndex=0;var nextKey,next,nextSeg,nextSub;while(nextIndex<literalsegments){nextKey=ES.ToString(nextIndex);nextSeg=ES.ToString(rawString[nextKey]);_push(stringElements,nextSeg);if(nextIndex+1>=literalsegments){break;}next=nextIndex+1<arguments.length?arguments[nextIndex+1]:'';nextSub=ES.ToString(next);_push(stringElements,nextSub);nextIndex+=1;}return stringElements.join('');}};if(String.raw&&String.raw({raw:{0:'x',1:'y',length:2}})!=='xy'){// IE 11 TP has a broken String.raw implementation
	overrideNative(String,'raw',StringShims.raw);}defineProperties(String,StringShims);// Fast repeat, uses the `Exponentiation by squaring` algorithm.
	// Perf: http://jsperf.com/string-repeat2/2
	var stringRepeat=function repeat(s,times){if(times<1){return'';}if(times%2){return repeat(s,times-1)+s;}var half=repeat(s,times/2);return half+half;};var stringMaxLength=Infinity;var StringPrototypeShims={repeat:function repeat(times){var thisStr=ES.ToString(ES.RequireObjectCoercible(this));var numTimes=ES.ToInteger(times);if(numTimes<0||numTimes>=stringMaxLength){throw new RangeError('repeat count must be less than infinity and not overflow maximum string size');}return stringRepeat(thisStr,numTimes);},startsWith:function startsWith(searchString){var S=ES.ToString(ES.RequireObjectCoercible(this));if(ES.IsRegExp(searchString)){throw new TypeError('Cannot call method "startsWith" with a regex');}var searchStr=ES.ToString(searchString);var position;if(arguments.length>1){position=arguments[1];}var start=_max(ES.ToInteger(position),0);return _strSlice(S,start,start+searchStr.length)===searchStr;},endsWith:function endsWith(searchString){var S=ES.ToString(ES.RequireObjectCoercible(this));if(ES.IsRegExp(searchString)){throw new TypeError('Cannot call method "endsWith" with a regex');}var searchStr=ES.ToString(searchString);var len=S.length;var endPosition;if(arguments.length>1){endPosition=arguments[1];}var pos=typeof endPosition==='undefined'?len:ES.ToInteger(endPosition);var end=_min(_max(pos,0),len);return _strSlice(S,end-searchStr.length,end)===searchStr;},includes:function includes(searchString){if(ES.IsRegExp(searchString)){throw new TypeError('"includes" does not accept a RegExp');}var searchStr=ES.ToString(searchString);var position;if(arguments.length>1){position=arguments[1];}// Somehow this trick makes method 100% compat with the spec.
	return _indexOf(this,searchStr,position)!==-1;},codePointAt:function codePointAt(pos){var thisStr=ES.ToString(ES.RequireObjectCoercible(this));var position=ES.ToInteger(pos);var length=thisStr.length;if(position>=0&&position<length){var first=thisStr.charCodeAt(position);var isEnd=position+1===length;if(first<0xD800||first>0xDBFF||isEnd){return first;}var second=thisStr.charCodeAt(position+1);if(second<0xDC00||second>0xDFFF){return first;}return(first-0xD800)*1024+(second-0xDC00)+0x10000;}}};if(String.prototype.includes&&'a'.includes('a',Infinity)!==false){overrideNative(String.prototype,'includes',StringPrototypeShims.includes);}if(String.prototype.startsWith&&String.prototype.endsWith){var startsWithRejectsRegex=throwsError(function(){/* throws if spec-compliant */'/a/'.startsWith(/a/);});var startsWithHandlesInfinity=valueOrFalseIfThrows(function(){return'abc'.startsWith('a',Infinity)===false;});if(!startsWithRejectsRegex||!startsWithHandlesInfinity){// Firefox (< 37?) and IE 11 TP have a noncompliant startsWith implementation
	overrideNative(String.prototype,'startsWith',StringPrototypeShims.startsWith);overrideNative(String.prototype,'endsWith',StringPrototypeShims.endsWith);}}if(hasSymbols){var startsWithSupportsSymbolMatch=valueOrFalseIfThrows(function(){var re=/a/;re[_Symbol.match]=false;return'/a/'.startsWith(re);});if(!startsWithSupportsSymbolMatch){overrideNative(String.prototype,'startsWith',StringPrototypeShims.startsWith);}var endsWithSupportsSymbolMatch=valueOrFalseIfThrows(function(){var re=/a/;re[_Symbol.match]=false;return'/a/'.endsWith(re);});if(!endsWithSupportsSymbolMatch){overrideNative(String.prototype,'endsWith',StringPrototypeShims.endsWith);}var includesSupportsSymbolMatch=valueOrFalseIfThrows(function(){var re=/a/;re[_Symbol.match]=false;return'/a/'.includes(re);});if(!includesSupportsSymbolMatch){overrideNative(String.prototype,'includes',StringPrototypeShims.includes);}}defineProperties(String.prototype,StringPrototypeShims);// whitespace from: http://es5.github.io/#x15.5.4.20
	// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
	var ws=['\t\n\u000b\f\r   ᠎    ','         　\u2028','\u2029'].join('');var trimRegexp=new RegExp('(^['+ws+']+)|(['+ws+']+$)','g');var trimShim=function trim(){return ES.ToString(ES.RequireObjectCoercible(this)).replace(trimRegexp,'');};var nonWS=['…','​','￾'].join('');var nonWSregex=new RegExp('['+nonWS+']','g');var isBadHexRegex=/^[\-+]0x[0-9a-f]+$/i;var hasStringTrimBug=nonWS.trim().length!==nonWS.length;defineProperty(String.prototype,'trim',trimShim,hasStringTrimBug);// Given an argument x, it will return an IteratorResult object,
	// with value set to x and done to false.
	// Given no arguments, it will return an iterator completion object.
	var iteratorResult=function iteratorResult(x){return{value:x,done:arguments.length===0};};// see http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype-@@iterator
	var StringIterator=function StringIterator(s){ES.RequireObjectCoercible(s);this._s=ES.ToString(s);this._i=0;};StringIterator.prototype.next=function(){var s=this._s;var i=this._i;if(typeof s==='undefined'||i>=s.length){this._s=void 0;return iteratorResult();}var first=s.charCodeAt(i);var second,len;if(first<0xD800||first>0xDBFF||i+1===s.length){len=1;}else{second=s.charCodeAt(i+1);len=second<0xDC00||second>0xDFFF?1:2;}this._i=i+len;return iteratorResult(s.substr(i,len));};addIterator(StringIterator.prototype);addIterator(String.prototype,function(){return new StringIterator(this);});var ArrayShims={from:function from(items){var C=this;var mapFn;if(arguments.length>1){mapFn=arguments[1];}var mapping,T;if(typeof mapFn==='undefined'){mapping=false;}else{if(!ES.IsCallable(mapFn)){throw new TypeError('Array.from: when provided, the second argument must be a function');}if(arguments.length>2){T=arguments[2];}mapping=true;}// Note that that Arrays will use ArrayIterator:
	// https://bugs.ecmascript.org/show_bug.cgi?id=2416
	var usingIterator=typeof(isArguments(items)||ES.GetMethod(items,$iterator$))!=='undefined';var length,result,i;if(usingIterator){result=ES.IsConstructor(C)?Object(new C()):[];var iterator=ES.GetIterator(items);var next,nextValue;i=0;while(true){next=ES.IteratorStep(iterator);if(next===false){break;}nextValue=next.value;try{if(mapping){nextValue=typeof T==='undefined'?mapFn(nextValue,i):_call(mapFn,T,nextValue,i);}result[i]=nextValue;}catch(e){ES.IteratorClose(iterator,true);throw e;}i+=1;}length=i;}else{var arrayLike=ES.ToObject(items);length=ES.ToLength(arrayLike.length);result=ES.IsConstructor(C)?Object(new C(length)):new Array(length);var value;for(i=0;i<length;++i){value=arrayLike[i];if(mapping){value=typeof T==='undefined'?mapFn(value,i):_call(mapFn,T,value,i);}createDataPropertyOrThrow(result,i,value);}}result.length=length;return result;},of:function of(){var len=arguments.length;var C=this;var A=isArray(C)||!ES.IsCallable(C)?new Array(len):ES.Construct(C,[len]);for(var k=0;k<len;++k){createDataPropertyOrThrow(A,k,arguments[k]);}A.length=len;return A;}};defineProperties(Array,ArrayShims);addDefaultSpecies(Array);// Our ArrayIterator is private; see
	// https://github.com/paulmillr/es6-shim/issues/252
	ArrayIterator=function ArrayIterator(array,kind){this.i=0;this.array=array;this.kind=kind;};defineProperties(ArrayIterator.prototype,{next:function next(){var i=this.i;var array=this.array;if(!(this instanceof ArrayIterator)){throw new TypeError('Not an ArrayIterator');}if(typeof array!=='undefined'){var len=ES.ToLength(array.length);for(;i<len;i++){var kind=this.kind;var retval;if(kind==='key'){retval=i;}else if(kind==='value'){retval=array[i];}else if(kind==='entry'){retval=[i,array[i]];}this.i=i+1;return iteratorResult(retval);}}this.array=void 0;return iteratorResult();}});addIterator(ArrayIterator.prototype);/*
	  var orderKeys = function orderKeys(a, b) {
	    var aNumeric = String(ES.ToInteger(a)) === a;
	    var bNumeric = String(ES.ToInteger(b)) === b;
	    if (aNumeric && bNumeric) {
	      return b - a;
	    } else if (aNumeric && !bNumeric) {
	      return -1;
	    } else if (!aNumeric && bNumeric) {
	      return 1;
	    } else {
	      return a.localeCompare(b);
	    }
	  };

	  var getAllKeys = function getAllKeys(object) {
	    var ownKeys = [];
	    var keys = [];

	    for (var key in object) {
	      _push(_hasOwnProperty(object, key) ? ownKeys : keys, key);
	    }
	    _sort(ownKeys, orderKeys);
	    _sort(keys, orderKeys);

	    return _concat(ownKeys, keys);
	  };
	  */// note: this is positioned here because it depends on ArrayIterator
	var arrayOfSupportsSubclassing=Array.of===ArrayShims.of||function(){// Detects a bug in Webkit nightly r181886
	var Foo=function Foo(len){this.length=len;};Foo.prototype=[];var fooArr=Array.of.apply(Foo,[1,2]);return fooArr instanceof Foo&&fooArr.length===2;}();if(!arrayOfSupportsSubclassing){overrideNative(Array,'of',ArrayShims.of);}var ArrayPrototypeShims={copyWithin:function copyWithin(target,start){var o=ES.ToObject(this);var len=ES.ToLength(o.length);var relativeTarget=ES.ToInteger(target);var relativeStart=ES.ToInteger(start);var to=relativeTarget<0?_max(len+relativeTarget,0):_min(relativeTarget,len);var from=relativeStart<0?_max(len+relativeStart,0):_min(relativeStart,len);var end;if(arguments.length>2){end=arguments[2];}var relativeEnd=typeof end==='undefined'?len:ES.ToInteger(end);var finalItem=relativeEnd<0?_max(len+relativeEnd,0):_min(relativeEnd,len);var count=_min(finalItem-from,len-to);var direction=1;if(from<to&&to<from+count){direction=-1;from+=count-1;to+=count-1;}while(count>0){if(from in o){o[to]=o[from];}else{delete o[to];}from+=direction;to+=direction;count-=1;}return o;},fill:function fill(value){var start;if(arguments.length>1){start=arguments[1];}var end;if(arguments.length>2){end=arguments[2];}var O=ES.ToObject(this);var len=ES.ToLength(O.length);start=ES.ToInteger(typeof start==='undefined'?0:start);end=ES.ToInteger(typeof end==='undefined'?len:end);var relativeStart=start<0?_max(len+start,0):_min(start,len);var relativeEnd=end<0?len+end:end;for(var i=relativeStart;i<len&&i<relativeEnd;++i){O[i]=value;}return O;},find:function find(predicate){var list=ES.ToObject(this);var length=ES.ToLength(list.length);if(!ES.IsCallable(predicate)){throw new TypeError('Array#find: predicate must be a function');}var thisArg=arguments.length>1?arguments[1]:null;for(var i=0,value;i<length;i++){value=list[i];if(thisArg){if(_call(predicate,thisArg,value,i,list)){return value;}}else if(predicate(value,i,list)){return value;}}},findIndex:function findIndex(predicate){var list=ES.ToObject(this);var length=ES.ToLength(list.length);if(!ES.IsCallable(predicate)){throw new TypeError('Array#findIndex: predicate must be a function');}var thisArg=arguments.length>1?arguments[1]:null;for(var i=0;i<length;i++){if(thisArg){if(_call(predicate,thisArg,list[i],i,list)){return i;}}else if(predicate(list[i],i,list)){return i;}}return-1;},keys:function keys(){return new ArrayIterator(this,'key');},values:function values(){return new ArrayIterator(this,'value');},entries:function entries(){return new ArrayIterator(this,'entry');}};// Safari 7.1 defines Array#keys and Array#entries natively,
	// but the resulting ArrayIterator objects don't have a "next" method.
	if(Array.prototype.keys&&!ES.IsCallable([1].keys().next)){delete Array.prototype.keys;}if(Array.prototype.entries&&!ES.IsCallable([1].entries().next)){delete Array.prototype.entries;}// Chrome 38 defines Array#keys and Array#entries, and Array#@@iterator, but not Array#values
	if(Array.prototype.keys&&Array.prototype.entries&&!Array.prototype.values&&Array.prototype[$iterator$]){defineProperties(Array.prototype,{values:Array.prototype[$iterator$]});if(Type.symbol(_Symbol.unscopables)){Array.prototype[_Symbol.unscopables].values=true;}}// Chrome 40 defines Array#values with the incorrect name, although Array#{keys,entries} have the correct name
	if(functionsHaveNames&&Array.prototype.values&&Array.prototype.values.name!=='values'){var originalArrayPrototypeValues=Array.prototype.values;overrideNative(Array.prototype,'values',function values(){return ES.Call(originalArrayPrototypeValues,this,arguments);});defineProperty(Array.prototype,$iterator$,Array.prototype.values,true);}defineProperties(Array.prototype,ArrayPrototypeShims);if(1/[true].indexOf(true,-0)<0){// indexOf when given a position arg of -0 should return +0.
	// https://github.com/tc39/ecma262/pull/316
	defineProperty(Array.prototype,'indexOf',function indexOf(searchElement){var value=_arrayIndexOfApply(this,arguments);if(value===0&&1/value<0){return 0;}return value;},true);}addIterator(Array.prototype,function(){return this.values();});// Chrome defines keys/values/entries on Array, but doesn't give us
	// any way to identify its iterator.  So add our own shimmed field.
	if(Object.getPrototypeOf){addIterator(Object.getPrototypeOf([].values()));}// note: this is positioned here because it relies on Array#entries
	var arrayFromSwallowsNegativeLengths=function(){// Detects a Firefox bug in v32
	// https://bugzilla.mozilla.org/show_bug.cgi?id=1063993
	return valueOrFalseIfThrows(function(){return Array.from({length:-1}).length===0;});}();var arrayFromHandlesIterables=function(){// Detects a bug in Webkit nightly r181886
	var arr=Array.from([0].entries());return arr.length===1&&isArray(arr[0])&&arr[0][0]===0&&arr[0][1]===0;}();if(!arrayFromSwallowsNegativeLengths||!arrayFromHandlesIterables){overrideNative(Array,'from',ArrayShims.from);}var arrayFromHandlesUndefinedMapFunction=function(){// Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,
	// but the spec doesn't care if it's provided or not - undefined doesn't throw.
	return valueOrFalseIfThrows(function(){return Array.from([0],void 0);});}();if(!arrayFromHandlesUndefinedMapFunction){var origArrayFrom=Array.from;overrideNative(Array,'from',function from(items){if(arguments.length>1&&typeof arguments[1]!=='undefined'){return ES.Call(origArrayFrom,this,arguments);}else{return _call(origArrayFrom,this,items);}});}var int32sAsOne=-(Math.pow(2,32)-1);var toLengthsCorrectly=function toLengthsCorrectly(method,reversed){var obj={length:int32sAsOne};obj[reversed?(obj.length>>>0)-1:0]=true;return valueOrFalseIfThrows(function(){_call(method,obj,function(){// note: in nonconforming browsers, this will be called
	// -1 >>> 0 times, which is 4294967295, so the throw matters.
	throw new RangeError('should not reach here');},[]);return true;});};if(!toLengthsCorrectly(Array.prototype.forEach)){var originalForEach=Array.prototype.forEach;overrideNative(Array.prototype,'forEach',function forEach(callbackFn){return ES.Call(originalForEach,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.map)){var originalMap=Array.prototype.map;overrideNative(Array.prototype,'map',function map(callbackFn){return ES.Call(originalMap,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.filter)){var originalFilter=Array.prototype.filter;overrideNative(Array.prototype,'filter',function filter(callbackFn){return ES.Call(originalFilter,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.some)){var originalSome=Array.prototype.some;overrideNative(Array.prototype,'some',function some(callbackFn){return ES.Call(originalSome,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.every)){var originalEvery=Array.prototype.every;overrideNative(Array.prototype,'every',function every(callbackFn){return ES.Call(originalEvery,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.reduce)){var originalReduce=Array.prototype.reduce;overrideNative(Array.prototype,'reduce',function reduce(callbackFn){return ES.Call(originalReduce,this.length>=0?this:[],arguments);},true);}if(!toLengthsCorrectly(Array.prototype.reduceRight,true)){var originalReduceRight=Array.prototype.reduceRight;overrideNative(Array.prototype,'reduceRight',function reduceRight(callbackFn){return ES.Call(originalReduceRight,this.length>=0?this:[],arguments);},true);}var lacksOctalSupport=Number('0o10')!==8;var lacksBinarySupport=Number('0b10')!==2;var trimsNonWhitespace=_some(nonWS,function(c){return Number(c+0+c)===0;});if(lacksOctalSupport||lacksBinarySupport||trimsNonWhitespace){var OrigNumber=Number;var binaryRegex=/^0b[01]+$/i;var octalRegex=/^0o[0-7]+$/i;// Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, "test" is an own property of regexes. wtf.
	var isBinary=binaryRegex.test.bind(binaryRegex);var isOctal=octalRegex.test.bind(octalRegex);var toPrimitive=function toPrimitive(O){// need to replace this with `es-to-primitive/es6`
	var result;if(typeof O.valueOf==='function'){result=O.valueOf();if(Type.primitive(result)){return result;}}if(typeof O.toString==='function'){result=O.toString();if(Type.primitive(result)){return result;}}throw new TypeError('No default value');};var hasNonWS=nonWSregex.test.bind(nonWSregex);var isBadHex=isBadHexRegex.test.bind(isBadHexRegex);var NumberShim=function(){// this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions.
	var NumberShim=function Number(value){var primValue;if(arguments.length>0){primValue=Type.primitive(value)?value:toPrimitive(value,'number');}else{primValue=0;}if(typeof primValue==='string'){primValue=ES.Call(trimShim,primValue);if(isBinary(primValue)){primValue=parseInt(_strSlice(primValue,2),2);}else if(isOctal(primValue)){primValue=parseInt(_strSlice(primValue,2),8);}else if(hasNonWS(primValue)||isBadHex(primValue)){primValue=NaN;}}var receiver=this;var valueOfSucceeds=valueOrFalseIfThrows(function(){OrigNumber.prototype.valueOf.call(receiver);return true;});if(receiver instanceof NumberShim&&!valueOfSucceeds){return new OrigNumber(primValue);}/* jshint newcap: false */return OrigNumber(primValue);/* jshint newcap: true */};return NumberShim;}();wrapConstructor(OrigNumber,NumberShim,{});// this is necessary for ES3 browsers, where these properties are non-enumerable.
	defineProperties(NumberShim,{NaN:OrigNumber.NaN,MAX_VALUE:OrigNumber.MAX_VALUE,MIN_VALUE:OrigNumber.MIN_VALUE,NEGATIVE_INFINITY:OrigNumber.NEGATIVE_INFINITY,POSITIVE_INFINITY:OrigNumber.POSITIVE_INFINITY});/* globals Number: true *//* eslint-disable no-undef *//* jshint -W020 */Number=NumberShim;Value.redefine(globals,'Number',NumberShim);/* jshint +W020 *//* eslint-enable no-undef *//* globals Number: false */}var maxSafeInteger=Math.pow(2,53)-1;defineProperties(Number,{MAX_SAFE_INTEGER:maxSafeInteger,MIN_SAFE_INTEGER:-maxSafeInteger,EPSILON:2.220446049250313e-16,parseInt:globals.parseInt,parseFloat:globals.parseFloat,isFinite:numberIsFinite,isInteger:function isInteger(value){return numberIsFinite(value)&&ES.ToInteger(value)===value;},isSafeInteger:function isSafeInteger(value){return Number.isInteger(value)&&_abs(value)<=Number.MAX_SAFE_INTEGER;},isNaN:numberIsNaN});// Firefox 37 has a conforming Number.parseInt, but it's not === to the global parseInt (fixed in v40)
	defineProperty(Number,'parseInt',globals.parseInt,Number.parseInt!==globals.parseInt);// Work around bugs in Array#find and Array#findIndex -- early
	// implementations skipped holes in sparse arrays. (Note that the
	// implementations of find/findIndex indirectly use shimmed
	// methods of Number, so this test has to happen down here.)
	/*jshint elision: true *//* eslint-disable no-sparse-arrays */if(![,1].find(function(item,idx){return idx===0;})){overrideNative(Array.prototype,'find',ArrayPrototypeShims.find);}if([,1].findIndex(function(item,idx){return idx===0;})!==0){overrideNative(Array.prototype,'findIndex',ArrayPrototypeShims.findIndex);}/* eslint-enable no-sparse-arrays *//*jshint elision: false */var isEnumerableOn=Function.bind.call(Function.bind,Object.prototype.propertyIsEnumerable);var ensureEnumerable=function ensureEnumerable(obj,prop){if(supportsDescriptors&&isEnumerableOn(obj,prop)){Object.defineProperty(obj,prop,{enumerable:false});}};var sliceArgs=function sliceArgs(){// per https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
	// and https://gist.github.com/WebReflection/4327762cb87a8c634a29
	var initial=Number(this);var len=arguments.length;var desiredArgCount=len-initial;var args=new Array(desiredArgCount<0?0:desiredArgCount);for(var i=initial;i<len;++i){args[i-initial]=arguments[i];}return args;};var assignTo=function assignTo(source){return function assignToSource(target,key){target[key]=source[key];return target;};};var assignReducer=function assignReducer(target,source){var sourceKeys=keys(Object(source));var symbols;if(ES.IsCallable(Object.getOwnPropertySymbols)){symbols=_filter(Object.getOwnPropertySymbols(Object(source)),isEnumerableOn(source));}return _reduce(_concat(sourceKeys,symbols||[]),assignTo(source),target);};var ObjectShims={// 19.1.3.1
	assign:function assign(target,source){var to=ES.ToObject(target,'Cannot convert undefined or null to object');return _reduce(ES.Call(sliceArgs,1,arguments),assignReducer,to);},// Added in WebKit in https://bugs.webkit.org/show_bug.cgi?id=143865
	is:function is(a,b){return ES.SameValue(a,b);}};var assignHasPendingExceptions=Object.assign&&Object.preventExtensions&&function(){// Firefox 37 still has "pending exception" logic in its Object.assign implementation,
	// which is 72% slower than our shim, and Firefox 40's native implementation.
	var thrower=Object.preventExtensions({1:2});try{Object.assign(thrower,'xy');}catch(e){return thrower[1]==='y';}}();if(assignHasPendingExceptions){overrideNative(Object,'assign',ObjectShims.assign);}defineProperties(Object,ObjectShims);if(supportsDescriptors){var ES5ObjectShims={// 19.1.3.9
	// shim from https://gist.github.com/WebReflection/5593554
	setPrototypeOf:function(Object,magic){var set;var checkArgs=function checkArgs(O,proto){if(!ES.TypeIsObject(O)){throw new TypeError('cannot set prototype on a non-object');}if(!(proto===null||ES.TypeIsObject(proto))){throw new TypeError('can only set prototype to an object or null'+proto);}};var setPrototypeOf=function setPrototypeOf(O,proto){checkArgs(O,proto);_call(set,O,proto);return O;};try{// this works already in Firefox and Safari
	set=Object.getOwnPropertyDescriptor(Object.prototype,magic).set;_call(set,{},null);}catch(e){if(Object.prototype!=={}[magic]){// IE < 11 cannot be shimmed
	return;}// probably Chrome or some old Mobile stock browser
	set=function set(proto){this[magic]=proto;};// please note that this will **not** work
	// in those browsers that do not inherit
	// __proto__ by mistake from Object.prototype
	// in these cases we should probably throw an error
	// or at least be informed about the issue
	setPrototypeOf.polyfill=setPrototypeOf(setPrototypeOf({},null),Object.prototype)instanceof Object;// setPrototypeOf.polyfill === true means it works as meant
	// setPrototypeOf.polyfill === false means it's not 100% reliable
	// setPrototypeOf.polyfill === undefined
	// or
	// setPrototypeOf.polyfill ==  null means it's not a polyfill
	// which means it works as expected
	// we can even delete Object.prototype.__proto__;
	}return setPrototypeOf;}(Object,'__proto__')};defineProperties(Object,ES5ObjectShims);}// Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work,
	// but Object.create(null) does.
	if(Object.setPrototypeOf&&Object.getPrototypeOf&&Object.getPrototypeOf(Object.setPrototypeOf({},null))!==null&&Object.getPrototypeOf(Object.create(null))===null){(function(){var FAKENULL=Object.create(null);var gpo=Object.getPrototypeOf;var spo=Object.setPrototypeOf;Object.getPrototypeOf=function(o){var result=gpo(o);return result===FAKENULL?null:result;};Object.setPrototypeOf=function(o,p){var proto=p===null?FAKENULL:p;return spo(o,proto);};Object.setPrototypeOf.polyfill=false;})();}var objectKeysAcceptsPrimitives=!throwsError(function(){Object.keys('foo');});if(!objectKeysAcceptsPrimitives){var originalObjectKeys=Object.keys;overrideNative(Object,'keys',function keys(value){return originalObjectKeys(ES.ToObject(value));});keys=Object.keys;}var objectKeysRejectsRegex=throwsError(function(){Object.keys(/a/g);});if(objectKeysRejectsRegex){var regexRejectingObjectKeys=Object.keys;overrideNative(Object,'keys',function keys(value){if(Type.regex(value)){var regexKeys=[];for(var k in value){if(_hasOwnProperty(value,k)){_push(regexKeys,k);}}return regexKeys;}return regexRejectingObjectKeys(value);});keys=Object.keys;}if(Object.getOwnPropertyNames){var objectGOPNAcceptsPrimitives=!throwsError(function(){Object.getOwnPropertyNames('foo');});if(!objectGOPNAcceptsPrimitives){var cachedWindowNames=(typeof window==='undefined'?'undefined':_typeof(window))==='object'?Object.getOwnPropertyNames(window):[];var originalObjectGetOwnPropertyNames=Object.getOwnPropertyNames;overrideNative(Object,'getOwnPropertyNames',function getOwnPropertyNames(value){var val=ES.ToObject(value);if(_toString(val)==='[object Window]'){try{return originalObjectGetOwnPropertyNames(val);}catch(e){// IE bug where layout engine calls userland gOPN for cross-domain `window` objects
	return _concat([],cachedWindowNames);}}return originalObjectGetOwnPropertyNames(val);});}}if(Object.getOwnPropertyDescriptor){var objectGOPDAcceptsPrimitives=!throwsError(function(){Object.getOwnPropertyDescriptor('foo','bar');});if(!objectGOPDAcceptsPrimitives){var originalObjectGetOwnPropertyDescriptor=Object.getOwnPropertyDescriptor;overrideNative(Object,'getOwnPropertyDescriptor',function getOwnPropertyDescriptor(value,property){return originalObjectGetOwnPropertyDescriptor(ES.ToObject(value),property);});}}if(Object.seal){var objectSealAcceptsPrimitives=!throwsError(function(){Object.seal('foo');});if(!objectSealAcceptsPrimitives){var originalObjectSeal=Object.seal;overrideNative(Object,'seal',function seal(value){if(!ES.TypeIsObject(value)){return value;}return originalObjectSeal(value);});}}if(Object.isSealed){var objectIsSealedAcceptsPrimitives=!throwsError(function(){Object.isSealed('foo');});if(!objectIsSealedAcceptsPrimitives){var originalObjectIsSealed=Object.isSealed;overrideNative(Object,'isSealed',function isSealed(value){if(!ES.TypeIsObject(value)){return true;}return originalObjectIsSealed(value);});}}if(Object.freeze){var objectFreezeAcceptsPrimitives=!throwsError(function(){Object.freeze('foo');});if(!objectFreezeAcceptsPrimitives){var originalObjectFreeze=Object.freeze;overrideNative(Object,'freeze',function freeze(value){if(!ES.TypeIsObject(value)){return value;}return originalObjectFreeze(value);});}}if(Object.isFrozen){var objectIsFrozenAcceptsPrimitives=!throwsError(function(){Object.isFrozen('foo');});if(!objectIsFrozenAcceptsPrimitives){var originalObjectIsFrozen=Object.isFrozen;overrideNative(Object,'isFrozen',function isFrozen(value){if(!ES.TypeIsObject(value)){return true;}return originalObjectIsFrozen(value);});}}if(Object.preventExtensions){var objectPreventExtensionsAcceptsPrimitives=!throwsError(function(){Object.preventExtensions('foo');});if(!objectPreventExtensionsAcceptsPrimitives){var originalObjectPreventExtensions=Object.preventExtensions;overrideNative(Object,'preventExtensions',function preventExtensions(value){if(!ES.TypeIsObject(value)){return value;}return originalObjectPreventExtensions(value);});}}if(Object.isExtensible){var objectIsExtensibleAcceptsPrimitives=!throwsError(function(){Object.isExtensible('foo');});if(!objectIsExtensibleAcceptsPrimitives){var originalObjectIsExtensible=Object.isExtensible;overrideNative(Object,'isExtensible',function isExtensible(value){if(!ES.TypeIsObject(value)){return false;}return originalObjectIsExtensible(value);});}}if(Object.getPrototypeOf){var objectGetProtoAcceptsPrimitives=!throwsError(function(){Object.getPrototypeOf('foo');});if(!objectGetProtoAcceptsPrimitives){var originalGetProto=Object.getPrototypeOf;overrideNative(Object,'getPrototypeOf',function getPrototypeOf(value){return originalGetProto(ES.ToObject(value));});}}var hasFlags=supportsDescriptors&&function(){var desc=Object.getOwnPropertyDescriptor(RegExp.prototype,'flags');return desc&&ES.IsCallable(desc.get);}();if(supportsDescriptors&&!hasFlags){var regExpFlagsGetter=function flags(){if(!ES.TypeIsObject(this)){throw new TypeError('Method called on incompatible type: must be an object.');}var result='';if(this.global){result+='g';}if(this.ignoreCase){result+='i';}if(this.multiline){result+='m';}if(this.unicode){result+='u';}if(this.sticky){result+='y';}return result;};Value.getter(RegExp.prototype,'flags',regExpFlagsGetter);}var regExpSupportsFlagsWithRegex=supportsDescriptors&&valueOrFalseIfThrows(function(){return String(new RegExp(/a/g,'i'))==='/a/i';});var regExpNeedsToSupportSymbolMatch=hasSymbols&&supportsDescriptors&&function(){// Edge 0.12 supports flags fully, but does not support Symbol.match
	var regex=/./;regex[_Symbol.match]=false;return RegExp(regex)===regex;}();var regexToStringIsGeneric=valueOrFalseIfThrows(function(){return RegExp.prototype.toString.call({source:'abc'})==='/abc/';});var regexToStringSupportsGenericFlags=regexToStringIsGeneric&&valueOrFalseIfThrows(function(){return RegExp.prototype.toString.call({source:'a',flags:'b'})==='/a/b';});if(!regexToStringIsGeneric||!regexToStringSupportsGenericFlags){var origRegExpToString=RegExp.prototype.toString;defineProperty(RegExp.prototype,'toString',function toString(){var R=ES.RequireObjectCoercible(this);if(Type.regex(R)){return _call(origRegExpToString,R);}var pattern=$String(R.source);var flags=$String(R.flags);return'/'+pattern+'/'+flags;},true);Value.preserveToString(RegExp.prototype.toString,origRegExpToString);}if(supportsDescriptors&&(!regExpSupportsFlagsWithRegex||regExpNeedsToSupportSymbolMatch)){var flagsGetter=Object.getOwnPropertyDescriptor(RegExp.prototype,'flags').get;var sourceDesc=Object.getOwnPropertyDescriptor(RegExp.prototype,'source')||{};var legacySourceGetter=function legacySourceGetter(){return this.source;};// prior to it being a getter, it's own + nonconfigurable
	var sourceGetter=ES.IsCallable(sourceDesc.get)?sourceDesc.get:legacySourceGetter;var OrigRegExp=RegExp;var RegExpShim=function(){return function RegExp(pattern,flags){var patternIsRegExp=ES.IsRegExp(pattern);var calledWithNew=this instanceof RegExp;if(!calledWithNew&&patternIsRegExp&&typeof flags==='undefined'&&pattern.constructor===RegExp){return pattern;}var P=pattern;var F=flags;if(Type.regex(pattern)){P=ES.Call(sourceGetter,pattern);F=typeof flags==='undefined'?ES.Call(flagsGetter,pattern):flags;return new RegExp(P,F);}else if(patternIsRegExp){P=pattern.source;F=typeof flags==='undefined'?pattern.flags:flags;}return new OrigRegExp(pattern,flags);};}();wrapConstructor(OrigRegExp,RegExpShim,{$input:true// Chrome < v39 & Opera < 26 have a nonstandard "$input" property
	});/* globals RegExp: true *//* eslint-disable no-undef *//* jshint -W020 */RegExp=RegExpShim;Value.redefine(globals,'RegExp',RegExpShim);/* jshint +W020 *//* eslint-enable no-undef *//* globals RegExp: false */}if(supportsDescriptors){var regexGlobals={input:'$_',lastMatch:'$&',lastParen:'$+',leftContext:'$`',rightContext:'$\''};_forEach(keys(regexGlobals),function(prop){if(prop in RegExp&&!(regexGlobals[prop]in RegExp)){Value.getter(RegExp,regexGlobals[prop],function get(){return RegExp[prop];});}});}addDefaultSpecies(RegExp);var inverseEpsilon=1/Number.EPSILON;var roundTiesToEven=function roundTiesToEven(n){// Even though this reduces down to `return n`, it takes advantage of built-in rounding.
	return n+inverseEpsilon-inverseEpsilon;};var BINARY_32_EPSILON=Math.pow(2,-23);var BINARY_32_MAX_VALUE=Math.pow(2,127)*(2-BINARY_32_EPSILON);var BINARY_32_MIN_VALUE=Math.pow(2,-126);var E=Math.E;var LOG2E=Math.LOG2E;var LOG10E=Math.LOG10E;var numberCLZ=Number.prototype.clz;delete Number.prototype.clz;// Safari 8 has Number#clz
	var MathShims={acosh:function acosh(value){var x=Number(value);if(numberIsNaN(x)||value<1){return NaN;}if(x===1){return 0;}if(x===Infinity){return x;}return _log(x/E+_sqrt(x+1)*_sqrt(x-1)/E)+1;},asinh:function asinh(value){var x=Number(value);if(x===0||!globalIsFinite(x)){return x;}return x<0?-asinh(-x):_log(x+_sqrt(x*x+1));},atanh:function atanh(value){var x=Number(value);if(numberIsNaN(x)||x<-1||x>1){return NaN;}if(x===-1){return-Infinity;}if(x===1){return Infinity;}if(x===0){return x;}return 0.5*_log((1+x)/(1-x));},cbrt:function cbrt(value){var x=Number(value);if(x===0){return x;}var negate=x<0;var result;if(negate){x=-x;}if(x===Infinity){result=Infinity;}else{result=_exp(_log(x)/3);// from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods
	result=(x/(result*result)+2*result)/3;}return negate?-result:result;},clz32:function clz32(value){// See https://bugs.ecmascript.org/show_bug.cgi?id=2465
	var x=Number(value);var number=ES.ToUint32(x);if(number===0){return 32;}return numberCLZ?ES.Call(numberCLZ,number):31-_floor(_log(number+0.5)*LOG2E);},cosh:function cosh(value){var x=Number(value);if(x===0){return 1;}// +0 or -0
	if(numberIsNaN(x)){return NaN;}if(!globalIsFinite(x)){return Infinity;}if(x<0){x=-x;}if(x>21){return _exp(x)/2;}return(_exp(x)+_exp(-x))/2;},expm1:function expm1(value){var x=Number(value);if(x===-Infinity){return-1;}if(!globalIsFinite(x)||x===0){return x;}if(_abs(x)>0.5){return _exp(x)-1;}// A more precise approximation using Taylor series expansion
	// from https://github.com/paulmillr/es6-shim/issues/314#issuecomment-70293986
	var t=x;var sum=0;var n=1;while(sum+t!==sum){sum+=t;n+=1;t*=x/n;}return sum;},hypot:function hypot(x,y){var result=0;var largest=0;for(var i=0;i<arguments.length;++i){var value=_abs(Number(arguments[i]));if(largest<value){result*=largest/value*(largest/value);result+=1;largest=value;}else{result+=value>0?value/largest*(value/largest):value;}}return largest===Infinity?Infinity:largest*_sqrt(result);},log2:function log2(value){return _log(value)*LOG2E;},log10:function log10(value){return _log(value)*LOG10E;},log1p:function log1p(value){var x=Number(value);if(x<-1||numberIsNaN(x)){return NaN;}if(x===0||x===Infinity){return x;}if(x===-1){return-Infinity;}return 1+x-1===0?x:x*(_log(1+x)/(1+x-1));},sign:_sign,sinh:function sinh(value){var x=Number(value);if(!globalIsFinite(x)||x===0){return x;}if(_abs(x)<1){return(Math.expm1(x)-Math.expm1(-x))/2;}return(_exp(x-1)-_exp(-x-1))*E/2;},tanh:function tanh(value){var x=Number(value);if(numberIsNaN(x)||x===0){return x;}// can exit early at +-20 as JS loses precision for true value at this integer
	if(x>=20){return 1;}if(x<=-20){return-1;}return(Math.expm1(x)-Math.expm1(-x))/(_exp(x)+_exp(-x));},trunc:function trunc(value){var x=Number(value);return x<0?-_floor(-x):_floor(x);},imul:function imul(x,y){// taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
	var a=ES.ToUint32(x);var b=ES.ToUint32(y);var ah=a>>>16&0xffff;var al=a&0xffff;var bh=b>>>16&0xffff;var bl=b&0xffff;// the shift by 0 fixes the sign on the high part
	// the final |0 converts the unsigned value into a signed value
	return al*bl+(ah*bl+al*bh<<16>>>0)|0;},fround:function fround(x){var v=Number(x);if(v===0||v===Infinity||v===-Infinity||numberIsNaN(v)){return v;}var sign=_sign(v);var abs=_abs(v);if(abs<BINARY_32_MIN_VALUE){return sign*roundTiesToEven(abs/BINARY_32_MIN_VALUE/BINARY_32_EPSILON)*BINARY_32_MIN_VALUE*BINARY_32_EPSILON;}// Veltkamp's splitting (?)
	var a=(1+BINARY_32_EPSILON/Number.EPSILON)*abs;var result=a-(a-abs);if(result>BINARY_32_MAX_VALUE||numberIsNaN(result)){return sign*Infinity;}return sign*result;}};defineProperties(Math,MathShims);// IE 11 TP has an imprecise log1p: reports Math.log1p(-1e-17) as 0
	defineProperty(Math,'log1p',MathShims.log1p,Math.log1p(-1e-17)!==-1e-17);// IE 11 TP has an imprecise asinh: reports Math.asinh(-1e7) as not exactly equal to -Math.asinh(1e7)
	defineProperty(Math,'asinh',MathShims.asinh,Math.asinh(-1e7)!==-Math.asinh(1e7));// Chrome 40 has an imprecise Math.tanh with very small numbers
	defineProperty(Math,'tanh',MathShims.tanh,Math.tanh(-2e-17)!==-2e-17);// Chrome 40 loses Math.acosh precision with high numbers
	defineProperty(Math,'acosh',MathShims.acosh,Math.acosh(Number.MAX_VALUE)===Infinity);// Firefox 38 on Windows
	defineProperty(Math,'cbrt',MathShims.cbrt,Math.abs(1-Math.cbrt(1e-300)/1e-100)/Number.EPSILON>8);// node 0.11 has an imprecise Math.sinh with very small numbers
	defineProperty(Math,'sinh',MathShims.sinh,Math.sinh(-2e-17)!==-2e-17);// FF 35 on Linux reports 22025.465794806725 for Math.expm1(10)
	var expm1OfTen=Math.expm1(10);defineProperty(Math,'expm1',MathShims.expm1,expm1OfTen>22025.465794806719||expm1OfTen<22025.4657948067165168);var origMathRound=Math.round;// breaks in e.g. Safari 8, Internet Explorer 11, Opera 12
	var roundHandlesBoundaryConditions=Math.round(0.5-Number.EPSILON/4)===0&&Math.round(-0.5+Number.EPSILON/3.99)===1;// When engines use Math.floor(x + 0.5) internally, Math.round can be buggy for large integers.
	// This behavior should be governed by "round to nearest, ties to even mode"
	// see http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-number-type
	// These are the boundary cases where it breaks.
	var smallestPositiveNumberWhereRoundBreaks=inverseEpsilon+1;var largestPositiveNumberWhereRoundBreaks=2*inverseEpsilon-1;var roundDoesNotIncreaseIntegers=[smallestPositiveNumberWhereRoundBreaks,largestPositiveNumberWhereRoundBreaks].every(function(num){return Math.round(num)===num;});defineProperty(Math,'round',function round(x){var floor=_floor(x);var ceil=floor===-1?-0:floor+1;return x-floor<0.5?floor:ceil;},!roundHandlesBoundaryConditions||!roundDoesNotIncreaseIntegers);Value.preserveToString(Math.round,origMathRound);var origImul=Math.imul;if(Math.imul(0xffffffff,5)!==-5){// Safari 6.1, at least, reports "0" for this value
	Math.imul=MathShims.imul;Value.preserveToString(Math.imul,origImul);}if(Math.imul.length!==2){// Safari 8.0.4 has a length of 1
	// fixed in https://bugs.webkit.org/show_bug.cgi?id=143658
	overrideNative(Math,'imul',function imul(x,y){return ES.Call(origImul,Math,arguments);});}// Promises
	// Simplest possible implementation; use a 3rd-party library if you
	// want the best possible speed and/or long stack traces.
	var PromiseShim=function(){var setTimeout=globals.setTimeout;// some environments don't have setTimeout - no way to shim here.
	if(typeof setTimeout!=='function'&&(typeof setTimeout==='undefined'?'undefined':_typeof(setTimeout))!=='object'){return;}ES.IsPromise=function(promise){if(!ES.TypeIsObject(promise)){return false;}if(typeof promise._promise==='undefined'){return false;// uninitialized, or missing our hidden field.
	}return true;};// "PromiseCapability" in the spec is what most promise implementations
	// call a "deferred".
	var PromiseCapability=function PromiseCapability(C){if(!ES.IsConstructor(C)){throw new TypeError('Bad promise constructor');}var capability=this;var resolver=function resolver(resolve,reject){if(capability.resolve!==void 0||capability.reject!==void 0){throw new TypeError('Bad Promise implementation!');}capability.resolve=resolve;capability.reject=reject;};// Initialize fields to inform optimizers about the object shape.
	capability.resolve=void 0;capability.reject=void 0;capability.promise=new C(resolver);if(!(ES.IsCallable(capability.resolve)&&ES.IsCallable(capability.reject))){throw new TypeError('Bad promise constructor');}};// find an appropriate setImmediate-alike
	var makeZeroTimeout;/*global window */if(typeof window!=='undefined'&&ES.IsCallable(window.postMessage)){makeZeroTimeout=function makeZeroTimeout(){// from http://dbaron.org/log/20100309-faster-timeouts
	var timeouts=[];var messageName='zero-timeout-message';var setZeroTimeout=function setZeroTimeout(fn){_push(timeouts,fn);window.postMessage(messageName,'*');};var handleMessage=function handleMessage(event){if(event.source===window&&event.data===messageName){event.stopPropagation();if(timeouts.length===0){return;}var fn=_shift(timeouts);fn();}};window.addEventListener('message',handleMessage,true);return setZeroTimeout;};}var makePromiseAsap=function makePromiseAsap(){// An efficient task-scheduler based on a pre-existing Promise
	// implementation, which we can use even if we override the
	// global Promise below (in order to workaround bugs)
	// https://github.com/Raynos/observ-hash/issues/2#issuecomment-35857671
	var P=globals.Promise;var pr=P&&P.resolve&&P.resolve();return pr&&function(task){return pr.then(task);};};/*global process *//* jscs:disable disallowMultiLineTernary */var enqueue=ES.IsCallable(globals.setImmediate)?globals.setImmediate:(typeof process==='undefined'?'undefined':_typeof(process))==='object'&&process.nextTick?process.nextTick:makePromiseAsap()||(ES.IsCallable(makeZeroTimeout)?makeZeroTimeout():function(task){setTimeout(task,0);});// fallback
	/* jscs:enable disallowMultiLineTernary */// Constants for Promise implementation
	var PROMISE_IDENTITY=function PROMISE_IDENTITY(x){return x;};var PROMISE_THROWER=function PROMISE_THROWER(e){throw e;};var PROMISE_PENDING=0;var PROMISE_FULFILLED=1;var PROMISE_REJECTED=2;// We store fulfill/reject handlers and capabilities in a single array.
	var PROMISE_FULFILL_OFFSET=0;var PROMISE_REJECT_OFFSET=1;var PROMISE_CAPABILITY_OFFSET=2;// This is used in an optimization for chaining promises via then.
	var PROMISE_FAKE_CAPABILITY={};var enqueuePromiseReactionJob=function enqueuePromiseReactionJob(handler,capability,argument){enqueue(function(){promiseReactionJob(handler,capability,argument);});};var promiseReactionJob=function promiseReactionJob(handler,promiseCapability,argument){var handlerResult,f;if(promiseCapability===PROMISE_FAKE_CAPABILITY){// Fast case, when we don't actually need to chain through to a
	// (real) promiseCapability.
	return handler(argument);}try{handlerResult=handler(argument);f=promiseCapability.resolve;}catch(e){handlerResult=e;f=promiseCapability.reject;}f(handlerResult);};var fulfillPromise=function fulfillPromise(promise,value){var _promise=promise._promise;var length=_promise.reactionLength;if(length>0){enqueuePromiseReactionJob(_promise.fulfillReactionHandler0,_promise.reactionCapability0,value);_promise.fulfillReactionHandler0=void 0;_promise.rejectReactions0=void 0;_promise.reactionCapability0=void 0;if(length>1){for(var i=1,idx=0;i<length;i++,idx+=3){enqueuePromiseReactionJob(_promise[idx+PROMISE_FULFILL_OFFSET],_promise[idx+PROMISE_CAPABILITY_OFFSET],value);promise[idx+PROMISE_FULFILL_OFFSET]=void 0;promise[idx+PROMISE_REJECT_OFFSET]=void 0;promise[idx+PROMISE_CAPABILITY_OFFSET]=void 0;}}}_promise.result=value;_promise.state=PROMISE_FULFILLED;_promise.reactionLength=0;};var rejectPromise=function rejectPromise(promise,reason){var _promise=promise._promise;var length=_promise.reactionLength;if(length>0){enqueuePromiseReactionJob(_promise.rejectReactionHandler0,_promise.reactionCapability0,reason);_promise.fulfillReactionHandler0=void 0;_promise.rejectReactions0=void 0;_promise.reactionCapability0=void 0;if(length>1){for(var i=1,idx=0;i<length;i++,idx+=3){enqueuePromiseReactionJob(_promise[idx+PROMISE_REJECT_OFFSET],_promise[idx+PROMISE_CAPABILITY_OFFSET],reason);promise[idx+PROMISE_FULFILL_OFFSET]=void 0;promise[idx+PROMISE_REJECT_OFFSET]=void 0;promise[idx+PROMISE_CAPABILITY_OFFSET]=void 0;}}}_promise.result=reason;_promise.state=PROMISE_REJECTED;_promise.reactionLength=0;};var createResolvingFunctions=function createResolvingFunctions(promise){var alreadyResolved=false;var resolve=function resolve(resolution){var then;if(alreadyResolved){return;}alreadyResolved=true;if(resolution===promise){return rejectPromise(promise,new TypeError('Self resolution'));}if(!ES.TypeIsObject(resolution)){return fulfillPromise(promise,resolution);}try{then=resolution.then;}catch(e){return rejectPromise(promise,e);}if(!ES.IsCallable(then)){return fulfillPromise(promise,resolution);}enqueue(function(){promiseResolveThenableJob(promise,resolution,then);});};var reject=function reject(reason){if(alreadyResolved){return;}alreadyResolved=true;return rejectPromise(promise,reason);};return{resolve:resolve,reject:reject};};var optimizedThen=function optimizedThen(then,thenable,resolve,reject){// Optimization: since we discard the result, we can pass our
	// own then implementation a special hint to let it know it
	// doesn't have to create it.  (The PROMISE_FAKE_CAPABILITY
	// object is local to this implementation and unforgeable outside.)
	if(then===Promise$prototype$then){_call(then,thenable,resolve,reject,PROMISE_FAKE_CAPABILITY);}else{_call(then,thenable,resolve,reject);}};var promiseResolveThenableJob=function promiseResolveThenableJob(promise,thenable,then){var resolvingFunctions=createResolvingFunctions(promise);var resolve=resolvingFunctions.resolve;var reject=resolvingFunctions.reject;try{optimizedThen(then,thenable,resolve,reject);}catch(e){reject(e);}};var Promise$prototype,Promise$prototype$then;var Promise=function(){var PromiseShim=function Promise(resolver){if(!(this instanceof PromiseShim)){throw new TypeError('Constructor Promise requires "new"');}if(this&&this._promise){throw new TypeError('Bad construction');}// see https://bugs.ecmascript.org/show_bug.cgi?id=2482
	if(!ES.IsCallable(resolver)){throw new TypeError('not a valid resolver');}var promise=emulateES6construct(this,PromiseShim,Promise$prototype,{_promise:{result:void 0,state:PROMISE_PENDING,// The first member of the "reactions" array is inlined here,
	// since most promises only have one reaction.
	// We've also exploded the 'reaction' object to inline the
	// "handler" and "capability" fields, since both fulfill and
	// reject reactions share the same capability.
	reactionLength:0,fulfillReactionHandler0:void 0,rejectReactionHandler0:void 0,reactionCapability0:void 0}});var resolvingFunctions=createResolvingFunctions(promise);var reject=resolvingFunctions.reject;try{resolver(resolvingFunctions.resolve,reject);}catch(e){reject(e);}return promise;};return PromiseShim;}();Promise$prototype=Promise.prototype;var _promiseAllResolver=function _promiseAllResolver(index,values,capability,remaining){var alreadyCalled=false;return function(x){if(alreadyCalled){return;}alreadyCalled=true;values[index]=x;if(--remaining.count===0){var resolve=capability.resolve;resolve(values);// call w/ this===undefined
	}};};var performPromiseAll=function performPromiseAll(iteratorRecord,C,resultCapability){var it=iteratorRecord.iterator;var values=[];var remaining={count:1};var next,nextValue;var index=0;while(true){try{next=ES.IteratorStep(it);if(next===false){iteratorRecord.done=true;break;}nextValue=next.value;}catch(e){iteratorRecord.done=true;throw e;}values[index]=void 0;var nextPromise=C.resolve(nextValue);var resolveElement=_promiseAllResolver(index,values,resultCapability,remaining);remaining.count+=1;optimizedThen(nextPromise.then,nextPromise,resolveElement,resultCapability.reject);index+=1;}if(--remaining.count===0){var resolve=resultCapability.resolve;resolve(values);// call w/ this===undefined
	}return resultCapability.promise;};var performPromiseRace=function performPromiseRace(iteratorRecord,C,resultCapability){var it=iteratorRecord.iterator;var next,nextValue,nextPromise;while(true){try{next=ES.IteratorStep(it);if(next===false){// NOTE: If iterable has no items, resulting promise will never
	// resolve; see:
	// https://github.com/domenic/promises-unwrapping/issues/75
	// https://bugs.ecmascript.org/show_bug.cgi?id=2515
	iteratorRecord.done=true;break;}nextValue=next.value;}catch(e){iteratorRecord.done=true;throw e;}nextPromise=C.resolve(nextValue);optimizedThen(nextPromise.then,nextPromise,resultCapability.resolve,resultCapability.reject);}return resultCapability.promise;};defineProperties(Promise,{all:function all(iterable){var C=this;if(!ES.TypeIsObject(C)){throw new TypeError('Promise is not object');}var capability=new PromiseCapability(C);var iterator,iteratorRecord;try{iterator=ES.GetIterator(iterable);iteratorRecord={iterator:iterator,done:false};return performPromiseAll(iteratorRecord,C,capability);}catch(e){var exception=e;if(iteratorRecord&&!iteratorRecord.done){try{ES.IteratorClose(iterator,true);}catch(ee){exception=ee;}}var reject=capability.reject;reject(exception);return capability.promise;}},race:function race(iterable){var C=this;if(!ES.TypeIsObject(C)){throw new TypeError('Promise is not object');}var capability=new PromiseCapability(C);var iterator,iteratorRecord;try{iterator=ES.GetIterator(iterable);iteratorRecord={iterator:iterator,done:false};return performPromiseRace(iteratorRecord,C,capability);}catch(e){var exception=e;if(iteratorRecord&&!iteratorRecord.done){try{ES.IteratorClose(iterator,true);}catch(ee){exception=ee;}}var reject=capability.reject;reject(exception);return capability.promise;}},reject:function reject(reason){var C=this;if(!ES.TypeIsObject(C)){throw new TypeError('Bad promise constructor');}var capability=new PromiseCapability(C);var rejectFunc=capability.reject;rejectFunc(reason);// call with this===undefined
	return capability.promise;},resolve:function resolve(v){// See https://esdiscuss.org/topic/fixing-promise-resolve for spec
	var C=this;if(!ES.TypeIsObject(C)){throw new TypeError('Bad promise constructor');}if(ES.IsPromise(v)){var constructor=v.constructor;if(constructor===C){return v;}}var capability=new PromiseCapability(C);var resolveFunc=capability.resolve;resolveFunc(v);// call with this===undefined
	return capability.promise;}});defineProperties(Promise$prototype,{'catch':function _catch(onRejected){return this.then(null,onRejected);},then:function then(onFulfilled,onRejected){var promise=this;if(!ES.IsPromise(promise)){throw new TypeError('not a promise');}var C=ES.SpeciesConstructor(promise,Promise);var resultCapability;var returnValueIsIgnored=arguments.length>2&&arguments[2]===PROMISE_FAKE_CAPABILITY;if(returnValueIsIgnored&&C===Promise){resultCapability=PROMISE_FAKE_CAPABILITY;}else{resultCapability=new PromiseCapability(C);}// PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)
	// Note that we've split the 'reaction' object into its two
	// components, "capabilities" and "handler"
	// "capabilities" is always equal to `resultCapability`
	var fulfillReactionHandler=ES.IsCallable(onFulfilled)?onFulfilled:PROMISE_IDENTITY;var rejectReactionHandler=ES.IsCallable(onRejected)?onRejected:PROMISE_THROWER;var _promise=promise._promise;var value;if(_promise.state===PROMISE_PENDING){if(_promise.reactionLength===0){_promise.fulfillReactionHandler0=fulfillReactionHandler;_promise.rejectReactionHandler0=rejectReactionHandler;_promise.reactionCapability0=resultCapability;}else{var idx=3*(_promise.reactionLength-1);_promise[idx+PROMISE_FULFILL_OFFSET]=fulfillReactionHandler;_promise[idx+PROMISE_REJECT_OFFSET]=rejectReactionHandler;_promise[idx+PROMISE_CAPABILITY_OFFSET]=resultCapability;}_promise.reactionLength+=1;}else if(_promise.state===PROMISE_FULFILLED){value=_promise.result;enqueuePromiseReactionJob(fulfillReactionHandler,resultCapability,value);}else if(_promise.state===PROMISE_REJECTED){value=_promise.result;enqueuePromiseReactionJob(rejectReactionHandler,resultCapability,value);}else{throw new TypeError('unexpected Promise state');}return resultCapability.promise;}});// This helps the optimizer by ensuring that methods which take
	// capabilities aren't polymorphic.
	PROMISE_FAKE_CAPABILITY=new PromiseCapability(Promise);Promise$prototype$then=Promise$prototype.then;return Promise;}();// Chrome's native Promise has extra methods that it shouldn't have. Let's remove them.
	if(globals.Promise){delete globals.Promise.accept;delete globals.Promise.defer;delete globals.Promise.prototype.chain;}if(typeof PromiseShim==='function'){// export the Promise constructor.
	defineProperties(globals,{Promise:PromiseShim});// In Chrome 33 (and thereabouts) Promise is defined, but the
	// implementation is buggy in a number of ways.  Let's check subclassing
	// support to see if we have a buggy implementation.
	var promiseSupportsSubclassing=supportsSubclassing(globals.Promise,function(S){return S.resolve(42).then(function(){})instanceof S;});var promiseIgnoresNonFunctionThenCallbacks=!throwsError(function(){globals.Promise.reject(42).then(null,5).then(null,noop);});var promiseRequiresObjectContext=throwsError(function(){globals.Promise.call(3,noop);});// Promise.resolve() was errata'ed late in the ES6 process.
	// See: https://bugzilla.mozilla.org/show_bug.cgi?id=1170742
	//      https://code.google.com/p/v8/issues/detail?id=4161
	// It serves as a proxy for a number of other bugs in early Promise
	// implementations.
	var promiseResolveBroken=function(Promise){var p=Promise.resolve(5);p.constructor={};var p2=Promise.resolve(p);try{p2.then(null,noop).then(null,noop);// avoid "uncaught rejection" warnings in console
	}catch(e){return true;// v8 native Promises break here https://code.google.com/p/chromium/issues/detail?id=575314
	}return p===p2;// This *should* be false!
	}(globals.Promise);// Chrome 46 (probably older too) does not retrieve a thenable's .then synchronously
	var getsThenSynchronously=supportsDescriptors&&function(){var count=0;var thenable=Object.defineProperty({},'then',{get:function get(){count+=1;}});Promise.resolve(thenable);return count===1;}();var BadResolverPromise=function BadResolverPromise(executor){var p=new Promise(executor);executor(3,function(){});this.then=p.then;this.constructor=BadResolverPromise;};BadResolverPromise.prototype=Promise.prototype;BadResolverPromise.all=Promise.all;// Chrome Canary 49 (probably older too) has some implementation bugs
	var hasBadResolverPromise=valueOrFalseIfThrows(function(){return!!BadResolverPromise.all([1,2]);});if(!promiseSupportsSubclassing||!promiseIgnoresNonFunctionThenCallbacks||!promiseRequiresObjectContext||promiseResolveBroken||!getsThenSynchronously||hasBadResolverPromise){/* globals Promise: true *//* eslint-disable no-undef *//* jshint -W020 */Promise=PromiseShim;/* jshint +W020 *//* eslint-enable no-undef *//* globals Promise: false */overrideNative(globals,'Promise',PromiseShim);}if(Promise.all.length!==1){var origAll=Promise.all;overrideNative(Promise,'all',function all(iterable){return ES.Call(origAll,this,arguments);});}if(Promise.race.length!==1){var origRace=Promise.race;overrideNative(Promise,'race',function race(iterable){return ES.Call(origRace,this,arguments);});}if(Promise.resolve.length!==1){var origResolve=Promise.resolve;overrideNative(Promise,'resolve',function resolve(x){return ES.Call(origResolve,this,arguments);});}if(Promise.reject.length!==1){var origReject=Promise.reject;overrideNative(Promise,'reject',function reject(r){return ES.Call(origReject,this,arguments);});}ensureEnumerable(Promise,'all');ensureEnumerable(Promise,'race');ensureEnumerable(Promise,'resolve');ensureEnumerable(Promise,'reject');addDefaultSpecies(Promise);}// Map and Set require a true ES5 environment
	// Their fast path also requires that the environment preserve
	// property insertion order, which is not guaranteed by the spec.
	var testOrder=function testOrder(a){var b=keys(_reduce(a,function(o,k){o[k]=true;return o;},{}));return a.join(':')===b.join(':');};var preservesInsertionOrder=testOrder(['z','a','bb']);// some engines (eg, Chrome) only preserve insertion order for string keys
	var preservesNumericInsertionOrder=testOrder(['z',1,'a','3',2]);if(supportsDescriptors){var fastkey=function fastkey(key){if(!preservesInsertionOrder){return null;}if(typeof key==='undefined'||key===null){return'^'+ES.ToString(key);}else if(typeof key==='string'){return'$'+key;}else if(typeof key==='number'){// note that -0 will get coerced to "0" when used as a property key
	if(!preservesNumericInsertionOrder){return'n'+key;}return key;}else if(typeof key==='boolean'){return'b'+key;}return null;};var emptyObject=function emptyObject(){// accomodate some older not-quite-ES5 browsers
	return Object.create?Object.create(null):{};};var addIterableToMap=function addIterableToMap(MapConstructor,map,iterable){if(isArray(iterable)||Type.string(iterable)){_forEach(iterable,function(entry){if(!ES.TypeIsObject(entry)){throw new TypeError('Iterator value '+entry+' is not an entry object');}map.set(entry[0],entry[1]);});}else if(iterable instanceof MapConstructor){_call(MapConstructor.prototype.forEach,iterable,function(value,key){map.set(key,value);});}else{var iter,adder;if(iterable!==null&&typeof iterable!=='undefined'){adder=map.set;if(!ES.IsCallable(adder)){throw new TypeError('bad map');}iter=ES.GetIterator(iterable);}if(typeof iter!=='undefined'){while(true){var next=ES.IteratorStep(iter);if(next===false){break;}var nextItem=next.value;try{if(!ES.TypeIsObject(nextItem)){throw new TypeError('Iterator value '+nextItem+' is not an entry object');}_call(adder,map,nextItem[0],nextItem[1]);}catch(e){ES.IteratorClose(iter,true);throw e;}}}}};var addIterableToSet=function addIterableToSet(SetConstructor,set,iterable){if(isArray(iterable)||Type.string(iterable)){_forEach(iterable,function(value){set.add(value);});}else if(iterable instanceof SetConstructor){_call(SetConstructor.prototype.forEach,iterable,function(value){set.add(value);});}else{var iter,adder;if(iterable!==null&&typeof iterable!=='undefined'){adder=set.add;if(!ES.IsCallable(adder)){throw new TypeError('bad set');}iter=ES.GetIterator(iterable);}if(typeof iter!=='undefined'){while(true){var next=ES.IteratorStep(iter);if(next===false){break;}var nextValue=next.value;try{_call(adder,set,nextValue);}catch(e){ES.IteratorClose(iter,true);throw e;}}}}};var collectionShims={Map:function(){var empty={};var MapEntry=function MapEntry(key,value){this.key=key;this.value=value;this.next=null;this.prev=null;};MapEntry.prototype.isRemoved=function isRemoved(){return this.key===empty;};var isMap=function isMap(map){return!!map._es6map;};var requireMapSlot=function requireMapSlot(map,method){if(!ES.TypeIsObject(map)||!isMap(map)){throw new TypeError('Method Map.prototype.'+method+' called on incompatible receiver '+ES.ToString(map));}};var MapIterator=function MapIterator(map,kind){requireMapSlot(map,'[[MapIterator]]');this.head=map._head;this.i=this.head;this.kind=kind;};MapIterator.prototype={next:function next(){var i=this.i;var kind=this.kind;var head=this.head;if(typeof this.i==='undefined'){return iteratorResult();}while(i.isRemoved()&&i!==head){// back up off of removed entries
	i=i.prev;}// advance to next unreturned element.
	var result;while(i.next!==head){i=i.next;if(!i.isRemoved()){if(kind==='key'){result=i.key;}else if(kind==='value'){result=i.value;}else{result=[i.key,i.value];}this.i=i;return iteratorResult(result);}}// once the iterator is done, it is done forever.
	this.i=void 0;return iteratorResult();}};addIterator(MapIterator.prototype);var Map$prototype;var MapShim=function Map(){if(!(this instanceof Map)){throw new TypeError('Constructor Map requires "new"');}if(this&&this._es6map){throw new TypeError('Bad construction');}var map=emulateES6construct(this,Map,Map$prototype,{_es6map:true,_head:null,_storage:emptyObject(),_size:0});var head=new MapEntry(null,null);// circular doubly-linked list.
	head.next=head.prev=head;map._head=head;// Optionally initialize map from iterable
	if(arguments.length>0){addIterableToMap(Map,map,arguments[0]);}return map;};Map$prototype=MapShim.prototype;Value.getter(Map$prototype,'size',function(){if(typeof this._size==='undefined'){throw new TypeError('size method called on incompatible Map');}return this._size;});defineProperties(Map$prototype,{get:function get(key){requireMapSlot(this,'get');var fkey=fastkey(key);if(fkey!==null){// fast O(1) path
	var entry=this._storage[fkey];if(entry){return entry.value;}else{return;}}var head=this._head;var i=head;while((i=i.next)!==head){if(ES.SameValueZero(i.key,key)){return i.value;}}},has:function has(key){requireMapSlot(this,'has');var fkey=fastkey(key);if(fkey!==null){// fast O(1) path
	return typeof this._storage[fkey]!=='undefined';}var head=this._head;var i=head;while((i=i.next)!==head){if(ES.SameValueZero(i.key,key)){return true;}}return false;},set:function set(key,value){requireMapSlot(this,'set');var head=this._head;var i=head;var entry;var fkey=fastkey(key);if(fkey!==null){// fast O(1) path
	if(typeof this._storage[fkey]!=='undefined'){this._storage[fkey].value=value;return this;}else{entry=this._storage[fkey]=new MapEntry(key,value);i=head.prev;// fall through
	}}while((i=i.next)!==head){if(ES.SameValueZero(i.key,key)){i.value=value;return this;}}entry=entry||new MapEntry(key,value);if(ES.SameValue(-0,key)){entry.key=+0;// coerce -0 to +0 in entry
	}entry.next=this._head;entry.prev=this._head.prev;entry.prev.next=entry;entry.next.prev=entry;this._size+=1;return this;},'delete':function _delete(key){requireMapSlot(this,'delete');var head=this._head;var i=head;var fkey=fastkey(key);if(fkey!==null){// fast O(1) path
	if(typeof this._storage[fkey]==='undefined'){return false;}i=this._storage[fkey].prev;delete this._storage[fkey];// fall through
	}while((i=i.next)!==head){if(ES.SameValueZero(i.key,key)){i.key=i.value=empty;i.prev.next=i.next;i.next.prev=i.prev;this._size-=1;return true;}}return false;},clear:function clear(){requireMapSlot(this,'clear');this._size=0;this._storage=emptyObject();var head=this._head;var i=head;var p=i.next;while((i=p)!==head){i.key=i.value=empty;p=i.next;i.next=i.prev=head;}head.next=head.prev=head;},keys:function keys(){requireMapSlot(this,'keys');return new MapIterator(this,'key');},values:function values(){requireMapSlot(this,'values');return new MapIterator(this,'value');},entries:function entries(){requireMapSlot(this,'entries');return new MapIterator(this,'key+value');},forEach:function forEach(callback){requireMapSlot(this,'forEach');var context=arguments.length>1?arguments[1]:null;var it=this.entries();for(var entry=it.next();!entry.done;entry=it.next()){if(context){_call(callback,context,entry.value[1],entry.value[0],this);}else{callback(entry.value[1],entry.value[0],this);}}}});addIterator(Map$prototype,Map$prototype.entries);return MapShim;}(),Set:function(){var isSet=function isSet(set){return set._es6set&&typeof set._storage!=='undefined';};var requireSetSlot=function requireSetSlot(set,method){if(!ES.TypeIsObject(set)||!isSet(set)){// https://github.com/paulmillr/es6-shim/issues/176
	throw new TypeError('Set.prototype.'+method+' called on incompatible receiver '+ES.ToString(set));}};// Creating a Map is expensive.  To speed up the common case of
	// Sets containing only string or numeric keys, we use an object
	// as backing storage and lazily create a full Map only when
	// required.
	var Set$prototype;var SetShim=function Set(){if(!(this instanceof Set)){throw new TypeError('Constructor Set requires "new"');}if(this&&this._es6set){throw new TypeError('Bad construction');}var set=emulateES6construct(this,Set,Set$prototype,{_es6set:true,'[[SetData]]':null,_storage:emptyObject()});if(!set._es6set){throw new TypeError('bad set');}// Optionally initialize Set from iterable
	if(arguments.length>0){addIterableToSet(Set,set,arguments[0]);}return set;};Set$prototype=SetShim.prototype;var decodeKey=function decodeKey(key){var k=key;if(k==='^null'){return null;}else if(k==='^undefined'){return void 0;}else{var first=k.charAt(0);if(first==='$'){return _strSlice(k,1);}else if(first==='n'){return+_strSlice(k,1);}else if(first==='b'){return k==='btrue';}}return+k;};// Switch from the object backing storage to a full Map.
	var ensureMap=function ensureMap(set){if(!set['[[SetData]]']){var m=set['[[SetData]]']=new collectionShims.Map();_forEach(keys(set._storage),function(key){var k=decodeKey(key);m.set(k,k);});set['[[SetData]]']=m;}set._storage=null;// free old backing storage
	};Value.getter(SetShim.prototype,'size',function(){requireSetSlot(this,'size');if(this._storage){return keys(this._storage).length;}ensureMap(this);return this['[[SetData]]'].size;});defineProperties(SetShim.prototype,{has:function has(key){requireSetSlot(this,'has');var fkey;if(this._storage&&(fkey=fastkey(key))!==null){return!!this._storage[fkey];}ensureMap(this);return this['[[SetData]]'].has(key);},add:function add(key){requireSetSlot(this,'add');var fkey;if(this._storage&&(fkey=fastkey(key))!==null){this._storage[fkey]=true;return this;}ensureMap(this);this['[[SetData]]'].set(key,key);return this;},'delete':function _delete(key){requireSetSlot(this,'delete');var fkey;if(this._storage&&(fkey=fastkey(key))!==null){var hasFKey=_hasOwnProperty(this._storage,fkey);return delete this._storage[fkey]&&hasFKey;}ensureMap(this);return this['[[SetData]]']['delete'](key);},clear:function clear(){requireSetSlot(this,'clear');if(this._storage){this._storage=emptyObject();}if(this['[[SetData]]']){this['[[SetData]]'].clear();}},values:function values(){requireSetSlot(this,'values');ensureMap(this);return this['[[SetData]]'].values();},entries:function entries(){requireSetSlot(this,'entries');ensureMap(this);return this['[[SetData]]'].entries();},forEach:function forEach(callback){requireSetSlot(this,'forEach');var context=arguments.length>1?arguments[1]:null;var entireSet=this;ensureMap(entireSet);this['[[SetData]]'].forEach(function(value,key){if(context){_call(callback,context,key,key,entireSet);}else{callback(key,key,entireSet);}});}});defineProperty(SetShim.prototype,'keys',SetShim.prototype.values,true);addIterator(SetShim.prototype,SetShim.prototype.values);return SetShim;}()};if(globals.Map||globals.Set){// Safari 8, for example, doesn't accept an iterable.
	var mapAcceptsArguments=valueOrFalseIfThrows(function(){return new Map([[1,2]]).get(1)===2;});if(!mapAcceptsArguments){var OrigMapNoArgs=globals.Map;globals.Map=function Map(){if(!(this instanceof Map)){throw new TypeError('Constructor Map requires "new"');}var m=new OrigMapNoArgs();if(arguments.length>0){addIterableToMap(Map,m,arguments[0]);}delete m.constructor;Object.setPrototypeOf(m,globals.Map.prototype);return m;};globals.Map.prototype=create(OrigMapNoArgs.prototype);defineProperty(globals.Map.prototype,'constructor',globals.Map,true);Value.preserveToString(globals.Map,OrigMapNoArgs);}var testMap=new Map();var mapUsesSameValueZero=function(){// Chrome 38-42, node 0.11/0.12, iojs 1/2 also have a bug when the Map has a size > 4
	var m=new Map([[1,0],[2,0],[3,0],[4,0]]);m.set(-0,m);return m.get(0)===m&&m.get(-0)===m&&m.has(0)&&m.has(-0);}();var mapSupportsChaining=testMap.set(1,2)===testMap;if(!mapUsesSameValueZero||!mapSupportsChaining){var origMapSet=Map.prototype.set;overrideNative(Map.prototype,'set',function set(k,v){_call(origMapSet,this,k===0?0:k,v);return this;});}if(!mapUsesSameValueZero){var origMapGet=Map.prototype.get;var origMapHas=Map.prototype.has;defineProperties(Map.prototype,{get:function get(k){return _call(origMapGet,this,k===0?0:k);},has:function has(k){return _call(origMapHas,this,k===0?0:k);}},true);Value.preserveToString(Map.prototype.get,origMapGet);Value.preserveToString(Map.prototype.has,origMapHas);}var testSet=new Set();var setUsesSameValueZero=function(s){s['delete'](0);s.add(-0);return!s.has(0);}(testSet);var setSupportsChaining=testSet.add(1)===testSet;if(!setUsesSameValueZero||!setSupportsChaining){var origSetAdd=Set.prototype.add;Set.prototype.add=function add(v){_call(origSetAdd,this,v===0?0:v);return this;};Value.preserveToString(Set.prototype.add,origSetAdd);}if(!setUsesSameValueZero){var origSetHas=Set.prototype.has;Set.prototype.has=function has(v){return _call(origSetHas,this,v===0?0:v);};Value.preserveToString(Set.prototype.has,origSetHas);var origSetDel=Set.prototype['delete'];Set.prototype['delete']=function SetDelete(v){return _call(origSetDel,this,v===0?0:v);};Value.preserveToString(Set.prototype['delete'],origSetDel);}var mapSupportsSubclassing=supportsSubclassing(globals.Map,function(M){var m=new M([]);// Firefox 32 is ok with the instantiating the subclass but will
	// throw when the map is used.
	m.set(42,42);return m instanceof M;});var mapFailsToSupportSubclassing=Object.setPrototypeOf&&!mapSupportsSubclassing;// without Object.setPrototypeOf, subclassing is not possible
	var mapRequiresNew=function(){try{return!(globals.Map()instanceof globals.Map);}catch(e){return e instanceof TypeError;}}();if(globals.Map.length!==0||mapFailsToSupportSubclassing||!mapRequiresNew){var OrigMap=globals.Map;globals.Map=function Map(){if(!(this instanceof Map)){throw new TypeError('Constructor Map requires "new"');}var m=new OrigMap();if(arguments.length>0){addIterableToMap(Map,m,arguments[0]);}delete m.constructor;Object.setPrototypeOf(m,Map.prototype);return m;};globals.Map.prototype=OrigMap.prototype;defineProperty(globals.Map.prototype,'constructor',globals.Map,true);Value.preserveToString(globals.Map,OrigMap);}var setSupportsSubclassing=supportsSubclassing(globals.Set,function(S){var s=new S([]);s.add(42,42);return s instanceof S;});var setFailsToSupportSubclassing=Object.setPrototypeOf&&!setSupportsSubclassing;// without Object.setPrototypeOf, subclassing is not possible
	var setRequiresNew=function(){try{return!(globals.Set()instanceof globals.Set);}catch(e){return e instanceof TypeError;}}();if(globals.Set.length!==0||setFailsToSupportSubclassing||!setRequiresNew){var OrigSet=globals.Set;globals.Set=function Set(){if(!(this instanceof Set)){throw new TypeError('Constructor Set requires "new"');}var s=new OrigSet();if(arguments.length>0){addIterableToSet(Set,s,arguments[0]);}delete s.constructor;Object.setPrototypeOf(s,Set.prototype);return s;};globals.Set.prototype=OrigSet.prototype;defineProperty(globals.Set.prototype,'constructor',globals.Set,true);Value.preserveToString(globals.Set,OrigSet);}var newMap=new globals.Map();var mapIterationThrowsStopIterator=!valueOrFalseIfThrows(function(){return newMap.keys().next().done;});/*
	        - In Firefox < 23, Map#size is a function.
	        - In all current Firefox, Set#entries/keys/values & Map#clear do not exist
	        - https://bugzilla.mozilla.org/show_bug.cgi?id=869996
	        - In Firefox 24, Map and Set do not implement forEach
	        - In Firefox 25 at least, Map and Set are callable without "new"
	      */if(typeof globals.Map.prototype.clear!=='function'||new globals.Set().size!==0||newMap.size!==0||typeof globals.Map.prototype.keys!=='function'||typeof globals.Set.prototype.keys!=='function'||typeof globals.Map.prototype.forEach!=='function'||typeof globals.Set.prototype.forEach!=='function'||isCallableWithoutNew(globals.Map)||isCallableWithoutNew(globals.Set)||typeof newMap.keys().next!=='function'||// Safari 8
	mapIterationThrowsStopIterator||// Firefox 25
	!mapSupportsSubclassing){defineProperties(globals,{Map:collectionShims.Map,Set:collectionShims.Set},true);}if(globals.Set.prototype.keys!==globals.Set.prototype.values){// Fixed in WebKit with https://bugs.webkit.org/show_bug.cgi?id=144190
	defineProperty(globals.Set.prototype,'keys',globals.Set.prototype.values,true);}// Shim incomplete iterator implementations.
	addIterator(Object.getPrototypeOf(new globals.Map().keys()));addIterator(Object.getPrototypeOf(new globals.Set().keys()));if(functionsHaveNames&&globals.Set.prototype.has.name!=='has'){// Microsoft Edge v0.11.10074.0 is missing a name on Set#has
	var anonymousSetHas=globals.Set.prototype.has;overrideNative(globals.Set.prototype,'has',function has(key){return _call(anonymousSetHas,this,key);});}}defineProperties(globals,collectionShims);addDefaultSpecies(globals.Map);addDefaultSpecies(globals.Set);}var throwUnlessTargetIsObject=function throwUnlessTargetIsObject(target){if(!ES.TypeIsObject(target)){throw new TypeError('target must be an object');}};// Some Reflect methods are basically the same as
	// those on the Object global, except that a TypeError is thrown if
	// target isn't an object. As well as returning a boolean indicating
	// the success of the operation.
	var ReflectShims={// Apply method in a functional form.
	apply:function apply(){return ES.Call(ES.Call,null,arguments);},// New operator in a functional form.
	construct:function construct(constructor,args){if(!ES.IsConstructor(constructor)){throw new TypeError('First argument must be a constructor.');}var newTarget=arguments.length>2?arguments[2]:constructor;if(!ES.IsConstructor(newTarget)){throw new TypeError('new.target must be a constructor.');}return ES.Construct(constructor,args,newTarget,'internal');},// When deleting a non-existent or configurable property,
	// true is returned.
	// When attempting to delete a non-configurable property,
	// it will return false.
	deleteProperty:function deleteProperty(target,key){throwUnlessTargetIsObject(target);if(supportsDescriptors){var desc=Object.getOwnPropertyDescriptor(target,key);if(desc&&!desc.configurable){return false;}}// Will return true.
	return delete target[key];},has:function has(target,key){throwUnlessTargetIsObject(target);return key in target;}};if(Object.getOwnPropertyNames){Object.assign(ReflectShims,{// Basically the result of calling the internal [[OwnPropertyKeys]].
	// Concatenating propertyNames and propertySymbols should do the trick.
	// This should continue to work together with a Symbol shim
	// which overrides Object.getOwnPropertyNames and implements
	// Object.getOwnPropertySymbols.
	ownKeys:function ownKeys(target){throwUnlessTargetIsObject(target);var keys=Object.getOwnPropertyNames(target);if(ES.IsCallable(Object.getOwnPropertySymbols)){_pushApply(keys,Object.getOwnPropertySymbols(target));}return keys;}});}var callAndCatchException=function ConvertExceptionToBoolean(func){return!throwsError(func);};if(Object.preventExtensions){Object.assign(ReflectShims,{isExtensible:function isExtensible(target){throwUnlessTargetIsObject(target);return Object.isExtensible(target);},preventExtensions:function preventExtensions(target){throwUnlessTargetIsObject(target);return callAndCatchException(function(){Object.preventExtensions(target);});}});}if(supportsDescriptors){var internalGet=function get(target,key,receiver){var desc=Object.getOwnPropertyDescriptor(target,key);if(!desc){var parent=Object.getPrototypeOf(target);if(parent===null){return void 0;}return internalGet(parent,key,receiver);}if('value'in desc){return desc.value;}if(desc.get){return ES.Call(desc.get,receiver);}return void 0;};var internalSet=function set(target,key,value,receiver){var desc=Object.getOwnPropertyDescriptor(target,key);if(!desc){var parent=Object.getPrototypeOf(target);if(parent!==null){return internalSet(parent,key,value,receiver);}desc={value:void 0,writable:true,enumerable:true,configurable:true};}if('value'in desc){if(!desc.writable){return false;}if(!ES.TypeIsObject(receiver)){return false;}var existingDesc=Object.getOwnPropertyDescriptor(receiver,key);if(existingDesc){return Reflect.defineProperty(receiver,key,{value:value});}else{return Reflect.defineProperty(receiver,key,{value:value,writable:true,enumerable:true,configurable:true});}}if(desc.set){_call(desc.set,receiver,value);return true;}return false;};Object.assign(ReflectShims,{defineProperty:function defineProperty(target,propertyKey,attributes){throwUnlessTargetIsObject(target);return callAndCatchException(function(){Object.defineProperty(target,propertyKey,attributes);});},getOwnPropertyDescriptor:function getOwnPropertyDescriptor(target,propertyKey){throwUnlessTargetIsObject(target);return Object.getOwnPropertyDescriptor(target,propertyKey);},// Syntax in a functional form.
	get:function get(target,key){throwUnlessTargetIsObject(target);var receiver=arguments.length>2?arguments[2]:target;return internalGet(target,key,receiver);},set:function set(target,key,value){throwUnlessTargetIsObject(target);var receiver=arguments.length>3?arguments[3]:target;return internalSet(target,key,value,receiver);}});}if(Object.getPrototypeOf){var objectDotGetPrototypeOf=Object.getPrototypeOf;ReflectShims.getPrototypeOf=function getPrototypeOf(target){throwUnlessTargetIsObject(target);return objectDotGetPrototypeOf(target);};}if(Object.setPrototypeOf&&ReflectShims.getPrototypeOf){var willCreateCircularPrototype=function willCreateCircularPrototype(object,lastProto){var proto=lastProto;while(proto){if(object===proto){return true;}proto=ReflectShims.getPrototypeOf(proto);}return false;};Object.assign(ReflectShims,{// Sets the prototype of the given object.
	// Returns true on success, otherwise false.
	setPrototypeOf:function setPrototypeOf(object,proto){throwUnlessTargetIsObject(object);if(proto!==null&&!ES.TypeIsObject(proto)){throw new TypeError('proto must be an object or null');}// If they already are the same, we're done.
	if(proto===Reflect.getPrototypeOf(object)){return true;}// Cannot alter prototype if object not extensible.
	if(Reflect.isExtensible&&!Reflect.isExtensible(object)){return false;}// Ensure that we do not create a circular prototype chain.
	if(willCreateCircularPrototype(object,proto)){return false;}Object.setPrototypeOf(object,proto);return true;}});}var defineOrOverrideReflectProperty=function defineOrOverrideReflectProperty(key,shim){if(!ES.IsCallable(globals.Reflect[key])){defineProperty(globals.Reflect,key,shim);}else{var acceptsPrimitives=valueOrFalseIfThrows(function(){globals.Reflect[key](1);globals.Reflect[key](NaN);globals.Reflect[key](true);return true;});if(acceptsPrimitives){overrideNative(globals.Reflect,key,shim);}}};Object.keys(ReflectShims).forEach(function(key){defineOrOverrideReflectProperty(key,ReflectShims[key]);});var originalReflectGetProto=globals.Reflect.getPrototypeOf;if(functionsHaveNames&&originalReflectGetProto&&originalReflectGetProto.name!=='getPrototypeOf'){overrideNative(globals.Reflect,'getPrototypeOf',function getPrototypeOf(target){return _call(originalReflectGetProto,globals.Reflect,target);});}if(globals.Reflect.setPrototypeOf){if(valueOrFalseIfThrows(function(){globals.Reflect.setPrototypeOf(1,{});return true;})){overrideNative(globals.Reflect,'setPrototypeOf',ReflectShims.setPrototypeOf);}}if(globals.Reflect.defineProperty){if(!valueOrFalseIfThrows(function(){var basic=!globals.Reflect.defineProperty(1,'test',{value:1});// "extensible" fails on Edge 0.12
	var extensible=typeof Object.preventExtensions!=='function'||!globals.Reflect.defineProperty(Object.preventExtensions({}),'test',{});return basic&&extensible;})){overrideNative(globals.Reflect,'defineProperty',ReflectShims.defineProperty);}}if(globals.Reflect.construct){if(!valueOrFalseIfThrows(function(){var F=function F(){};return globals.Reflect.construct(function(){},[],F)instanceof F;})){overrideNative(globals.Reflect,'construct',ReflectShims.construct);}}if(String(new Date(NaN))!=='Invalid Date'){var dateToString=Date.prototype.toString;var shimmedDateToString=function toString(){var valueOf=+this;if(valueOf!==valueOf){return'Invalid Date';}return ES.Call(dateToString,this);};overrideNative(Date.prototype,'toString',shimmedDateToString);}// Annex B HTML methods
	// http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-string.prototype-object
	var stringHTMLshims={anchor:function anchor(name){return ES.CreateHTML(this,'a','name',name);},big:function big(){return ES.CreateHTML(this,'big','','');},blink:function blink(){return ES.CreateHTML(this,'blink','','');},bold:function bold(){return ES.CreateHTML(this,'b','','');},fixed:function fixed(){return ES.CreateHTML(this,'tt','','');},fontcolor:function fontcolor(color){return ES.CreateHTML(this,'font','color',color);},fontsize:function fontsize(size){return ES.CreateHTML(this,'font','size',size);},italics:function italics(){return ES.CreateHTML(this,'i','','');},link:function link(url){return ES.CreateHTML(this,'a','href',url);},small:function small(){return ES.CreateHTML(this,'small','','');},strike:function strike(){return ES.CreateHTML(this,'strike','','');},sub:function sub(){return ES.CreateHTML(this,'sub','','');},sup:function sub(){return ES.CreateHTML(this,'sup','','');}};_forEach(Object.keys(stringHTMLshims),function(key){var method=String.prototype[key];var shouldOverwrite=false;if(ES.IsCallable(method)){var output=_call(method,'',' " ');var quotesCount=_concat([],output.match(/"/g)).length;shouldOverwrite=output!==output.toLowerCase()||quotesCount>2;}else{shouldOverwrite=true;}if(shouldOverwrite){overrideNative(String.prototype,key,stringHTMLshims[key]);}});var JSONstringifiesSymbols=function(){// Microsoft Edge v0.12 stringifies Symbols incorrectly
	if(!hasSymbols){return false;}// Symbols are not supported
	var stringify=(typeof JSON==='undefined'?'undefined':_typeof(JSON))==='object'&&typeof JSON.stringify==='function'?JSON.stringify:null;if(!stringify){return false;}// JSON.stringify is not supported
	if(typeof stringify(_Symbol())!=='undefined'){return true;}// Symbols should become `undefined`
	if(stringify([_Symbol()])!=='[null]'){return true;}// Symbols in arrays should become `null`
	var obj={a:_Symbol()};obj[_Symbol()]=true;if(stringify(obj)!=='{}'){return true;}// Symbol-valued keys *and* Symbol-valued properties should be omitted
	return false;}();var JSONstringifyAcceptsObjectSymbol=valueOrFalseIfThrows(function(){// Chrome 45 throws on stringifying object symbols
	if(!hasSymbols){return true;}// Symbols are not supported
	return JSON.stringify(Object(_Symbol()))==='{}'&&JSON.stringify([Object(_Symbol())])==='[{}]';});if(JSONstringifiesSymbols||!JSONstringifyAcceptsObjectSymbol){var origStringify=JSON.stringify;overrideNative(JSON,'stringify',function stringify(value){if((typeof value==='undefined'?'undefined':_typeof(value))==='symbol'){return;}var replacer;if(arguments.length>1){replacer=arguments[1];}var args=[value];if(!isArray(replacer)){var replaceFn=ES.IsCallable(replacer)?replacer:null;var wrappedReplacer=function wrappedReplacer(key,val){var parsedValue=replaceFn?_call(replaceFn,this,key,val):val;if((typeof parsedValue==='undefined'?'undefined':_typeof(parsedValue))!=='symbol'){if(Type.symbol(parsedValue)){return assignTo({})(parsedValue);}else{return parsedValue;}}};args.push(wrappedReplacer);}else{// create wrapped replacer that handles an array replacer?
	args.push(replacer);}if(arguments.length>2){args.push(arguments[2]);}return origStringify.apply(this,args);});}return globals;});
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(3)))

/***/ },
/* 3 */
/***/ function(module, exports) {

	'use strict';

	// shim for using process in browser

	var process = module.exports = {};

	// cached from whatever global is present so that test runners that stub it
	// don't break things.  But we need to wrap it in a try catch in case it is
	// wrapped in strict mode code which doesn't define any globals.  It's inside a
	// function because try/catches deoptimize in certain engines.

	var cachedSetTimeout;
	var cachedClearTimeout;

	(function () {
	    try {
	        cachedSetTimeout = setTimeout;
	    } catch (e) {
	        cachedSetTimeout = function cachedSetTimeout() {
	            throw new Error('setTimeout is not defined');
	        };
	    }
	    try {
	        cachedClearTimeout = clearTimeout;
	    } catch (e) {
	        cachedClearTimeout = function cachedClearTimeout() {
	            throw new Error('clearTimeout is not defined');
	        };
	    }
	})();
	var queue = [];
	var draining = false;
	var currentQueue;
	var queueIndex = -1;

	function cleanUpNextTick() {
	    if (!draining || !currentQueue) {
	        return;
	    }
	    draining = false;
	    if (currentQueue.length) {
	        queue = currentQueue.concat(queue);
	    } else {
	        queueIndex = -1;
	    }
	    if (queue.length) {
	        drainQueue();
	    }
	}

	function drainQueue() {
	    if (draining) {
	        return;
	    }
	    var timeout = cachedSetTimeout(cleanUpNextTick);
	    draining = true;

	    var len = queue.length;
	    while (len) {
	        currentQueue = queue;
	        queue = [];
	        while (++queueIndex < len) {
	            if (currentQueue) {
	                currentQueue[queueIndex].run();
	            }
	        }
	        queueIndex = -1;
	        len = queue.length;
	    }
	    currentQueue = null;
	    draining = false;
	    cachedClearTimeout(timeout);
	}

	process.nextTick = function (fun) {
	    var args = new Array(arguments.length - 1);
	    if (arguments.length > 1) {
	        for (var i = 1; i < arguments.length; i++) {
	            args[i - 1] = arguments[i];
	        }
	    }
	    queue.push(new Item(fun, args));
	    if (queue.length === 1 && !draining) {
	        cachedSetTimeout(drainQueue, 0);
	    }
	};

	// v8 likes predictible objects
	function Item(fun, array) {
	    this.fun = fun;
	    this.array = array;
	}
	Item.prototype.run = function () {
	    this.fun.apply(null, this.array);
	};
	process.title = 'browser';
	process.browser = true;
	process.env = {};
	process.argv = [];
	process.version = ''; // empty string to avoid regexp issues
	process.versions = {};

	function noop() {}

	process.on = noop;
	process.addListener = noop;
	process.once = noop;
	process.off = noop;
	process.removeListener = noop;
	process.removeAllListeners = noop;
	process.emit = noop;

	process.binding = function (name) {
	    throw new Error('process.binding is not supported');
	};

	process.cwd = function () {
	    return '/';
	};
	process.chdir = function (dir) {
	    throw new Error('process.chdir is not supported');
	};
	process.umask = function () {
	    return 0;
	};

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	/*
	* loglevel - https://github.com/pimterry/loglevel
	*
	* Copyright (c) 2013 Tim Perry
	* Licensed under the MIT license.
	*/
	(function (root, definition) {
	    "use strict";

	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_FACTORY__ = (definition), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	    } else if ((typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object' && module.exports) {
	        module.exports = definition();
	    } else {
	        root.log = definition();
	    }
	})(undefined, function () {
	    "use strict";

	    var noop = function noop() {};
	    var undefinedType = "undefined";

	    function realMethod(methodName) {
	        if ((typeof console === 'undefined' ? 'undefined' : _typeof(console)) === undefinedType) {
	            return false; // We can't build a real method without a console to log to
	        } else if (console[methodName] !== undefined) {
	                return bindMethod(console, methodName);
	            } else if (console.log !== undefined) {
	                return bindMethod(console, 'log');
	            } else {
	                return noop;
	            }
	    }

	    function bindMethod(obj, methodName) {
	        var method = obj[methodName];
	        if (typeof method.bind === 'function') {
	            return method.bind(obj);
	        } else {
	            try {
	                return Function.prototype.bind.call(method, obj);
	            } catch (e) {
	                // Missing bind shim or IE8 + Modernizr, fallback to wrapping
	                return function () {
	                    return Function.prototype.apply.apply(method, [obj, arguments]);
	                };
	            }
	        }
	    }

	    // these private functions always need `this` to be set properly

	    function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
	        return function () {
	            if ((typeof console === 'undefined' ? 'undefined' : _typeof(console)) !== undefinedType) {
	                replaceLoggingMethods.call(this, level, loggerName);
	                this[methodName].apply(this, arguments);
	            }
	        };
	    }

	    function replaceLoggingMethods(level, loggerName) {
	        /*jshint validthis:true */
	        for (var i = 0; i < logMethods.length; i++) {
	            var methodName = logMethods[i];
	            this[methodName] = i < level ? noop : this.methodFactory(methodName, level, loggerName);
	        }
	    }

	    function defaultMethodFactory(methodName, level, loggerName) {
	        /*jshint validthis:true */
	        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
	    }

	    var logMethods = ["trace", "debug", "info", "warn", "error"];

	    function Logger(name, defaultLevel, factory) {
	        var self = this;
	        var currentLevel;
	        var storageKey = "loglevel";
	        if (name) {
	            storageKey += ":" + name;
	        }

	        function persistLevelIfPossible(levelNum) {
	            var levelName = (logMethods[levelNum] || 'silent').toUpperCase();

	            // Use localStorage if available
	            try {
	                window.localStorage[storageKey] = levelName;
	                return;
	            } catch (ignore) {}

	            // Use session cookie as fallback
	            try {
	                window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
	            } catch (ignore) {}
	        }

	        function getPersistedLevel() {
	            var storedLevel;

	            try {
	                storedLevel = window.localStorage[storageKey];
	            } catch (ignore) {}

	            if ((typeof storedLevel === 'undefined' ? 'undefined' : _typeof(storedLevel)) === undefinedType) {
	                try {
	                    var cookie = window.document.cookie;
	                    var location = cookie.indexOf(encodeURIComponent(storageKey) + "=");
	                    if (location) {
	                        storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
	                    }
	                } catch (ignore) {}
	            }

	            // If the stored level is not valid, treat it as if nothing was stored.
	            if (self.levels[storedLevel] === undefined) {
	                storedLevel = undefined;
	            }

	            return storedLevel;
	        }

	        /*
	         *
	         * Public API
	         *
	         */

	        self.levels = { "TRACE": 0, "DEBUG": 1, "INFO": 2, "WARN": 3,
	            "ERROR": 4, "SILENT": 5 };

	        self.methodFactory = factory || defaultMethodFactory;

	        self.getLevel = function () {
	            return currentLevel;
	        };

	        self.setLevel = function (level, persist) {
	            if (typeof level === "string" && self.levels[level.toUpperCase()] !== undefined) {
	                level = self.levels[level.toUpperCase()];
	            }
	            if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
	                currentLevel = level;
	                if (persist !== false) {
	                    // defaults to true
	                    persistLevelIfPossible(level);
	                }
	                replaceLoggingMethods.call(self, level, name);
	                if ((typeof console === 'undefined' ? 'undefined' : _typeof(console)) === undefinedType && level < self.levels.SILENT) {
	                    return "No console available for logging";
	                }
	            } else {
	                throw "log.setLevel() called with invalid level: " + level;
	            }
	        };

	        self.setDefaultLevel = function (level) {
	            if (!getPersistedLevel()) {
	                self.setLevel(level, false);
	            }
	        };

	        self.enableAll = function (persist) {
	            self.setLevel(self.levels.TRACE, persist);
	        };

	        self.disableAll = function (persist) {
	            self.setLevel(self.levels.SILENT, persist);
	        };

	        // Initialize with the right level
	        var initialLevel = getPersistedLevel();
	        if (initialLevel == null) {
	            initialLevel = defaultLevel == null ? "WARN" : defaultLevel;
	        }
	        self.setLevel(initialLevel, false);
	    }

	    /*
	     *
	     * Package-level API
	     *
	     */

	    var defaultLogger = new Logger();

	    var _loggersByName = {};
	    defaultLogger.getLogger = function getLogger(name) {
	        if (typeof name !== "string" || name === "") {
	            throw new TypeError("You must supply a name when creating a logger.");
	        }

	        var logger = _loggersByName[name];
	        if (!logger) {
	            logger = _loggersByName[name] = new Logger(name, defaultLogger.getLevel(), defaultLogger.methodFactory);
	        }
	        return logger;
	    };

	    // Grab the current global log variable in case of overwrite
	    var _log = (typeof window === 'undefined' ? 'undefined' : _typeof(window)) !== undefinedType ? window.log : undefined;
	    defaultLogger.noConflict = function () {
	        if ((typeof window === 'undefined' ? 'undefined' : _typeof(window)) !== undefinedType && window.log === defaultLogger) {
	            window.log = _log;
	        }

	        return defaultLogger;
	    };

	    return defaultLogger;
	});

/***/ },
/* 5 */
/***/ function(module, exports) {

	"use strict";

	var config = {
	  verbose: false,
	  debug: false
	};

	module.exports = config;

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	var SurveyMan = SurveyMan || {};

	var _ = __webpack_require__(7);
	var $ = __webpack_require__(8);

	__webpack_require__(10);

	var display = function () {

	    document.cookies = "test=EMMA_COOKIE_TEST";

	    var SurveyMan;

	    var questionsChosen = [],
	        dropdownThreshold = 7,
	        id = 0,
	        DUMMY_ID = "dummy",
	        SUBMIT_FINAL = "submit_final",
	        SUBMIT_PREFIX = "submit_",
	        NEXT_PREFIX = "next_",
	        MTURK_FORM = "mturk_form";

	    var hideNextButton = function hideNextButton(q) {

	        $("#" + NEXT_PREFIX + q.id).remove();
	        $("#" + SUBMIT_PREFIX + q.id).remove();
	        $("#" + SUBMIT_FINAL).remove();
	    },
	        showNextButton = function showNextButton(pid, q, o) {
	        var id, nextHTML;
	        id = NEXT_PREFIX + q.id;
	        if ($("#" + id).length > 0) document.getElementById(id).onclick = function () {
	            registerAnswerAndShowNextQuestion(pid, q, o);
	        };else if (!finalSubmit()) {
	            nextHTML = document.createElement("input");
	            nextHTML.id = id;
	            nextHTML.type = "button";
	            nextHTML.onclick = function () {
	                $("#" + q.id).hide();
	                registerAnswerAndShowNextQuestion(pid, q, o);
	            };
	            nextHTML.value = "Next";
	            $("div[name=question]").append(nextHTML);
	        }
	        showSubmit(q, o);
	    },
	        getNextQuestion = function getNextQuestion(q, o) {

	        var nextQ;
	        if (o && !_.isUndefined(q.branchMap)) {
	            // returns a block
	            nextQ = SurveyMan.interpreter.handleBranching(q, o);
	        } else {
	            // get the next sequential question
	            //console.log("get next sequential question after " + q.id + "(" + q.qtext + ")" );
	            nextQ = SurveyMan.interpreter.nextSequential();
	        }
	        return nextQ;
	    },
	        showQuestion = function showQuestion(q) {

	        $(".question").empty();
	        $(".question").append(q.qtext);
	        $(".question").attr({ name: q.id });
	    },
	        getNextID = function getNextID() {

	        id += 1;
	        return "ans" + id;
	    },
	        testFreetext = function testFreetext(freetext, text) {
	        var matches = freetext.exec(text);
	        return _.contains(matches, text);
	    },
	        setReturnValueForFreetext = function setReturnValueForFreetext(q, o, qpos) {

	        var retval = { "quid": q.id, "oid": "comp_-1_-1", "qpos": qpos, "opos": -1, "text": o.value };
	        o.value = JSON.stringify(retval);
	    },
	        getOptionHTML = function getOptionHTML(q) {

	        // would like to replace text area, select, etc. with JS objects
	        var opt,
	            i,
	            elt,
	            dummy,
	            qpos = questionsChosen.length,
	            pid = getNextID(),
	            par = document.createElement("p");

	        par.id = pid;
	        $(par).attr({ name: q.id });

	        if (q.freetext) {

	            elt = document.createElement("textarea");
	            elt.id = q.id;
	            elt.type = "text";
	            elt.oninput = function () {
	                var response = document.getElementById(elt.id);
	                if (q.freetext instanceof RegExp) {
	                    var inputText = response.value;
	                    if (testFreetext(q.freetext, inputText)) showNextButton(pid, q, response, qpos);
	                } else showNextButton(pid, q, response, qpos);
	            };
	            elt.name = q.id;
	            if (q.freetext instanceof String) elt.placeholder = q.freetext;
	            elt.form = MTURK_FORM;
	            $(par).append(elt);
	        } else if (_.isUndefined(q.options) || q.options.length == 0) {

	            dummy = getDummyOpt(q);

	            if (!finalSubmit()) showNextButton(pid, q, dummy);
	            showSubmit(q, dummy);
	        } else if (q.options.length > dropdownThreshold && q.exclusive) {

	            elt = document.createElement("select");
	            elt.id = "select_" + q.id;
	            elt.onchange = function () {
	                var thing = getDropdownOpt(q);
	                if (_.isUndefined(thing)) hideNextButton(q);else showNextButton(pid, q, thing);
	            };
	            $(elt).attr({ name: q.id, form: MTURK_FORM });
	            if (!q.exclusive) {
	                $(elt).prop("multiple", true);
	            }

	            dummy = document.createElement('option');
	            dummy.id = DUMMY_ID;
	            dummy.text = "CHOOSE ONE";
	            $(dummy).attr({ disable: true, selected: true });
	            $(dummy).attr({ onselect: function onselect() {
	                    hideNextButton(q);
	                } });
	            elt.options[elt.options.length] = dummy;

	            for (i = 0; i < q.options.length; i++) {
	                opt = q.options[i];
	                elt.add(makeDropDown(pid, q, opt, qpos, i));
	            }

	            $(par).append(elt);
	        } else {

	            for (i = 0; i < q.options.length; i++) {

	                if (q.options.length === 1 && q.options[0].otext === "null") {
	                    // no options; just display next
	                    showNextButton(null, q, null);
	                    return "";
	                }

	                opt = q.options[i];
	                elt = document.createElement("label");
	                $(elt).attr("for", opt.oid);
	                $(elt).append(makeRadioOrCheck(pid, q, opt, qpos, i));
	                $(elt).append(opt.otext);
	                $(par).append(elt);
	            }
	        }
	        return par;
	    },
	        showOptions = function showOptions(q) {
	        $(".answer").empty();
	        var opts = getOptionHTML(q);
	        $(".answer").append(opts);
	        if (finalSubmit() && submitNotYetShown() && q.options.length === 0) showSubmit(q, true);
	    },
	        registerAnswerAndShowNextQuestion = function registerAnswerAndShowNextQuestion(pid, q, o) {
	        // if we're coming from an instructional question, just skip registering
	        if (o) {
	            $("form").append($("#" + pid));
	            $("#" + pid).hide();
	        }

	        if (q.freetext) {
	            setReturnValueForFreetext(q, o);
	        }

	        questionsChosen.push(q);
	        $("#" + NEXT_PREFIX + q.id).remove();
	        $("#" + SUBMIT_PREFIX + q.id).remove();
	        q = getNextQuestion(q, o);
	        showQuestion(q);
	        showOptions(q);
	    },
	        makeDropDown = function makeDropDown(pid, q, opt, qpos, opos) {

	        var ojson = { "quid": q.id, "oid": opt.id, "qpos": qpos, "opos": opos },
	            o = document.createElement("option");

	        o.text = opt.otext;
	        o.value = JSON.stringify(ojson);
	        o.id = opt.id;

	        return o;
	    },
	        makeRadioOrCheck = function makeRadioOrCheck(pid, q, opt, qpos, opos) {

	        var ojson = { "quid": q.id, "oid": opt.id, "qpos": qpos, "opos": opos },
	            o = document.createElement("input");

	        o.type = q.exclusive ? "radio" : "checkbox";
	        o.id = opt.id;
	        o.onchange = function () {
	            if (o.type === "checkbox") {
	                var toSelect = "[name=" + q.id + "] :checked";
	                if ($(toSelect).length === 0) {
	                    hideNextButton(q);
	                    return;
	                }
	            }
	            showNextButton(pid, q, opt);
	        };
	        o.name = q.id;
	        o.value = JSON.stringify(ojson);
	        // o.form = MTURK_FORM;

	        return o;
	    },
	        getDummyOpt = function getDummyOpt(q) {

	        return new Option({ "id": "comp_-1_-1", "otext": "" }, q);
	    },
	        finalSubmit = function finalSubmit() {

	        return SurveyMan.interpreter.isQuestionStackEmpty() && SurveyMan.interpreter.isBlockStackEmpty();
	    },
	        showEarlySubmit = function showEarlySubmit(q) {

	        return q.breakoff && q.options.length != 0;
	    },
	        showBreakoffNotice = function showBreakoffNotice(msg) {

	        $(".question").append("<p>" + msg + "</p>");
	        $("div[name=question]").show();
	        $(".question").append("<input type=\"button\" id=\"continue\" value=\"Continue\" " + "onclick=\"SurveyMan.display.showFirstQuestion();\" />");
	    },
	        showFirstQuestion = function showFirstQuestion() {

	        var firstQ = SurveyMan.interpreter.nextQuestion();
	        showQuestion(firstQ);
	        showOptions(firstQ);
	    },
	        freetextValid = function freetextValid(q, o) {

	        if (_.isUndefined(q.freetext) || !q.freetext) {
	            return true;
	        } else if (q.freetext instanceof String) {
	            return true;
	        } else if ((q.freetext instanceof Boolean || typeof q.freetext === "boolean") && q.freetext) {
	            return o.value != "";
	        } else if (q.freetext instanceof RegExp) {
	            return testFreetext(q.freetext, o.value);
	        } else throw "Unknown type of freetext: " + _typeof(q.freetext);
	    },
	        showSubmit = function showSubmit(q, o) {

	        var submitHTML;
	        if (submitNotYetShown()) {
	            submitHTML = document.createElement("input");
	            submitHTML.type = "submit";
	            submitHTML.onclick = function () {
	                if (q.freetext) {
	                    $("#" + q.id).hide();
	                    setReturnValueForFreetext(q, o);
	                }
	            };
	            if (finalSubmit() && freetextValid(q, o)) {
	                submitHTML.defaultValue = "Submit";
	                submitHTML.id = SUBMIT_FINAL;
	            } else if (showEarlySubmit(q) && o || freetextValid(q, o)) {
	                submitHTML.defaultValue = "Submit Early";
	                submitHTML.classList.add("breakoff");
	                submitHTML.id = SUBMIT_PREFIX + q.id;
	            } else return;
	            $("div[name=question]").append(submitHTML);
	        }
	    },
	        submitNotYetShown = function submitNotYetShown() {

	        var submits = $(":submit");
	        return submits.length === 0;
	    },
	        getDropdownOpt = function getDropdownOpt(q) {

	        var dropdownOpt = $("#select_" + q.id + " option:selected"),
	            oid = dropdownOpt.attr("id");
	        if (oid === DUMMY_ID) return;
	        return SurveyMan.survey.getOptionById(oid);
	    };

	    return {
	        hideNextButton: hideNextButton,
	        showNextButton: showNextButton,
	        getNextQuestion: getNextQuestion,
	        showQuestion: showQuestion,
	        getOptionHTML: getOptionHTML,
	        showOptions: showOptions,
	        registerAnswerAndShowNextQuestion: registerAnswerAndShowNextQuestion,
	        showBreakoffNotice: showBreakoffNotice,
	        showFirstQuestion: showFirstQuestion,
	        showSubmit: showSubmit,
	        ready: function ready(assignmentId, mturk, jsonizedSurvey, loadPreview, customInit, breakoffMsg) {

	            if (typeof customInit === "function") {
	                customInit();
	                console.log("C");
	            }
	            //  Previewing for now is unique to mturk.
	            $(document).ready(function () {

	                SurveyMan = window.SurveyMan.surveyman;

	                var start_survey = function start_survey() {
	                    $("#preview").hide();
	                    Math.seedrandom(assignmentId);
	                    console.log(jsonizedSurvey);
	                    var sm = SurveyMan.interpreter.init(jsonizedSurvey);
	                    if (sm.breakoff) {
	                        showBreakoffNotice(breakoffMsg);
	                    } else {
	                        showFirstQuestion();
	                        $("div[name=question]").show();
	                    }
	                };
	                assignmentId = mturk && _.isUndefined(assignmentId) ? "ASSIGNMENT_ID_NOT_AVAILABLE" : document.getElementById('assignmentId').value;
	                console.log(assignmentId);

	                $('form').submit(function () {
	                    window.onbeforeunload = null;
	                });

	                var preview = $("#preview");

	                if (assignmentId == "ASSIGNMENT_ID_NOT_AVAILABLE" && typeof loadPreview === "function") {
	                    loadPreview();
	                    preview.show();
	                } else {
	                    var nextButton = document.createElement("input");
	                    nextButton.type = "button";
	                    nextButton.onclick = start_survey;
	                    nextButton.value = "Start Survey";
	                    preview.append(nextButton);
	                    preview.show();
	                }
	            });
	        }
	    };
	}();

	module.exports = display;

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	//     Underscore.js 1.8.3
	//     http://underscorejs.org
	//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	//     Underscore may be freely distributed under the MIT license.

	(function () {

	  // Baseline setup
	  // --------------

	  // Establish the root object, `window` in the browser, or `exports` on the server.
	  var root = this;

	  // Save the previous value of the `_` variable.
	  var previousUnderscore = root._;

	  // Save bytes in the minified (but not gzipped) version:
	  var ArrayProto = Array.prototype,
	      ObjProto = Object.prototype,
	      FuncProto = Function.prototype;

	  // Create quick reference variables for speed access to core prototypes.
	  var push = ArrayProto.push,
	      slice = ArrayProto.slice,
	      toString = ObjProto.toString,
	      hasOwnProperty = ObjProto.hasOwnProperty;

	  // All **ECMAScript 5** native function implementations that we hope to use
	  // are declared here.
	  var nativeIsArray = Array.isArray,
	      nativeKeys = Object.keys,
	      nativeBind = FuncProto.bind,
	      nativeCreate = Object.create;

	  // Naked function reference for surrogate-prototype-swapping.
	  var Ctor = function Ctor() {};

	  // Create a safe reference to the Underscore object for use below.
	  var _ = function _(obj) {
	    if (obj instanceof _) return obj;
	    if (!(this instanceof _)) return new _(obj);
	    this._wrapped = obj;
	  };

	  // Export the Underscore object for **Node.js**, with
	  // backwards-compatibility for the old `require()` API. If we're in
	  // the browser, add `_` as a global object.
	  if (true) {
	    if (typeof module !== 'undefined' && module.exports) {
	      exports = module.exports = _;
	    }
	    exports._ = _;
	  } else {
	    root._ = _;
	  }

	  // Current version.
	  _.VERSION = '1.8.3';

	  // Internal function that returns an efficient (for current engines) version
	  // of the passed-in callback, to be repeatedly applied in other Underscore
	  // functions.
	  var optimizeCb = function optimizeCb(func, context, argCount) {
	    if (context === void 0) return func;
	    switch (argCount == null ? 3 : argCount) {
	      case 1:
	        return function (value) {
	          return func.call(context, value);
	        };
	      case 2:
	        return function (value, other) {
	          return func.call(context, value, other);
	        };
	      case 3:
	        return function (value, index, collection) {
	          return func.call(context, value, index, collection);
	        };
	      case 4:
	        return function (accumulator, value, index, collection) {
	          return func.call(context, accumulator, value, index, collection);
	        };
	    }
	    return function () {
	      return func.apply(context, arguments);
	    };
	  };

	  // A mostly-internal function to generate callbacks that can be applied
	  // to each element in a collection, returning the desired result — either
	  // identity, an arbitrary callback, a property matcher, or a property accessor.
	  var cb = function cb(value, context, argCount) {
	    if (value == null) return _.identity;
	    if (_.isFunction(value)) return optimizeCb(value, context, argCount);
	    if (_.isObject(value)) return _.matcher(value);
	    return _.property(value);
	  };
	  _.iteratee = function (value, context) {
	    return cb(value, context, Infinity);
	  };

	  // An internal function for creating assigner functions.
	  var createAssigner = function createAssigner(keysFunc, undefinedOnly) {
	    return function (obj) {
	      var length = arguments.length;
	      if (length < 2 || obj == null) return obj;
	      for (var index = 1; index < length; index++) {
	        var source = arguments[index],
	            keys = keysFunc(source),
	            l = keys.length;
	        for (var i = 0; i < l; i++) {
	          var key = keys[i];
	          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
	        }
	      }
	      return obj;
	    };
	  };

	  // An internal function for creating a new object that inherits from another.
	  var baseCreate = function baseCreate(prototype) {
	    if (!_.isObject(prototype)) return {};
	    if (nativeCreate) return nativeCreate(prototype);
	    Ctor.prototype = prototype;
	    var result = new Ctor();
	    Ctor.prototype = null;
	    return result;
	  };

	  var property = function property(key) {
	    return function (obj) {
	      return obj == null ? void 0 : obj[key];
	    };
	  };

	  // Helper for collection methods to determine whether a collection
	  // should be iterated as an array or as an object
	  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
	  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
	  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
	  var getLength = property('length');
	  var isArrayLike = function isArrayLike(collection) {
	    var length = getLength(collection);
	    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
	  };

	  // Collection Functions
	  // --------------------

	  // The cornerstone, an `each` implementation, aka `forEach`.
	  // Handles raw objects in addition to array-likes. Treats all
	  // sparse array-likes as if they were dense.
	  _.each = _.forEach = function (obj, iteratee, context) {
	    iteratee = optimizeCb(iteratee, context);
	    var i, length;
	    if (isArrayLike(obj)) {
	      for (i = 0, length = obj.length; i < length; i++) {
	        iteratee(obj[i], i, obj);
	      }
	    } else {
	      var keys = _.keys(obj);
	      for (i = 0, length = keys.length; i < length; i++) {
	        iteratee(obj[keys[i]], keys[i], obj);
	      }
	    }
	    return obj;
	  };

	  // Return the results of applying the iteratee to each element.
	  _.map = _.collect = function (obj, iteratee, context) {
	    iteratee = cb(iteratee, context);
	    var keys = !isArrayLike(obj) && _.keys(obj),
	        length = (keys || obj).length,
	        results = Array(length);
	    for (var index = 0; index < length; index++) {
	      var currentKey = keys ? keys[index] : index;
	      results[index] = iteratee(obj[currentKey], currentKey, obj);
	    }
	    return results;
	  };

	  // Create a reducing function iterating left or right.
	  function createReduce(dir) {
	    // Optimized iterator function as using arguments.length
	    // in the main function will deoptimize the, see #1991.
	    function iterator(obj, iteratee, memo, keys, index, length) {
	      for (; index >= 0 && index < length; index += dir) {
	        var currentKey = keys ? keys[index] : index;
	        memo = iteratee(memo, obj[currentKey], currentKey, obj);
	      }
	      return memo;
	    }

	    return function (obj, iteratee, memo, context) {
	      iteratee = optimizeCb(iteratee, context, 4);
	      var keys = !isArrayLike(obj) && _.keys(obj),
	          length = (keys || obj).length,
	          index = dir > 0 ? 0 : length - 1;
	      // Determine the initial value if none is provided.
	      if (arguments.length < 3) {
	        memo = obj[keys ? keys[index] : index];
	        index += dir;
	      }
	      return iterator(obj, iteratee, memo, keys, index, length);
	    };
	  }

	  // **Reduce** builds up a single result from a list of values, aka `inject`,
	  // or `foldl`.
	  _.reduce = _.foldl = _.inject = createReduce(1);

	  // The right-associative version of reduce, also known as `foldr`.
	  _.reduceRight = _.foldr = createReduce(-1);

	  // Return the first value which passes a truth test. Aliased as `detect`.
	  _.find = _.detect = function (obj, predicate, context) {
	    var key;
	    if (isArrayLike(obj)) {
	      key = _.findIndex(obj, predicate, context);
	    } else {
	      key = _.findKey(obj, predicate, context);
	    }
	    if (key !== void 0 && key !== -1) return obj[key];
	  };

	  // Return all the elements that pass a truth test.
	  // Aliased as `select`.
	  _.filter = _.select = function (obj, predicate, context) {
	    var results = [];
	    predicate = cb(predicate, context);
	    _.each(obj, function (value, index, list) {
	      if (predicate(value, index, list)) results.push(value);
	    });
	    return results;
	  };

	  // Return all the elements for which a truth test fails.
	  _.reject = function (obj, predicate, context) {
	    return _.filter(obj, _.negate(cb(predicate)), context);
	  };

	  // Determine whether all of the elements match a truth test.
	  // Aliased as `all`.
	  _.every = _.all = function (obj, predicate, context) {
	    predicate = cb(predicate, context);
	    var keys = !isArrayLike(obj) && _.keys(obj),
	        length = (keys || obj).length;
	    for (var index = 0; index < length; index++) {
	      var currentKey = keys ? keys[index] : index;
	      if (!predicate(obj[currentKey], currentKey, obj)) return false;
	    }
	    return true;
	  };

	  // Determine if at least one element in the object matches a truth test.
	  // Aliased as `any`.
	  _.some = _.any = function (obj, predicate, context) {
	    predicate = cb(predicate, context);
	    var keys = !isArrayLike(obj) && _.keys(obj),
	        length = (keys || obj).length;
	    for (var index = 0; index < length; index++) {
	      var currentKey = keys ? keys[index] : index;
	      if (predicate(obj[currentKey], currentKey, obj)) return true;
	    }
	    return false;
	  };

	  // Determine if the array or object contains a given item (using `===`).
	  // Aliased as `includes` and `include`.
	  _.contains = _.includes = _.include = function (obj, item, fromIndex, guard) {
	    if (!isArrayLike(obj)) obj = _.values(obj);
	    if (typeof fromIndex != 'number' || guard) fromIndex = 0;
	    return _.indexOf(obj, item, fromIndex) >= 0;
	  };

	  // Invoke a method (with arguments) on every item in a collection.
	  _.invoke = function (obj, method) {
	    var args = slice.call(arguments, 2);
	    var isFunc = _.isFunction(method);
	    return _.map(obj, function (value) {
	      var func = isFunc ? method : value[method];
	      return func == null ? func : func.apply(value, args);
	    });
	  };

	  // Convenience version of a common use case of `map`: fetching a property.
	  _.pluck = function (obj, key) {
	    return _.map(obj, _.property(key));
	  };

	  // Convenience version of a common use case of `filter`: selecting only objects
	  // containing specific `key:value` pairs.
	  _.where = function (obj, attrs) {
	    return _.filter(obj, _.matcher(attrs));
	  };

	  // Convenience version of a common use case of `find`: getting the first object
	  // containing specific `key:value` pairs.
	  _.findWhere = function (obj, attrs) {
	    return _.find(obj, _.matcher(attrs));
	  };

	  // Return the maximum element (or element-based computation).
	  _.max = function (obj, iteratee, context) {
	    var result = -Infinity,
	        lastComputed = -Infinity,
	        value,
	        computed;
	    if (iteratee == null && obj != null) {
	      obj = isArrayLike(obj) ? obj : _.values(obj);
	      for (var i = 0, length = obj.length; i < length; i++) {
	        value = obj[i];
	        if (value > result) {
	          result = value;
	        }
	      }
	    } else {
	      iteratee = cb(iteratee, context);
	      _.each(obj, function (value, index, list) {
	        computed = iteratee(value, index, list);
	        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
	          result = value;
	          lastComputed = computed;
	        }
	      });
	    }
	    return result;
	  };

	  // Return the minimum element (or element-based computation).
	  _.min = function (obj, iteratee, context) {
	    var result = Infinity,
	        lastComputed = Infinity,
	        value,
	        computed;
	    if (iteratee == null && obj != null) {
	      obj = isArrayLike(obj) ? obj : _.values(obj);
	      for (var i = 0, length = obj.length; i < length; i++) {
	        value = obj[i];
	        if (value < result) {
	          result = value;
	        }
	      }
	    } else {
	      iteratee = cb(iteratee, context);
	      _.each(obj, function (value, index, list) {
	        computed = iteratee(value, index, list);
	        if (computed < lastComputed || computed === Infinity && result === Infinity) {
	          result = value;
	          lastComputed = computed;
	        }
	      });
	    }
	    return result;
	  };

	  // Shuffle a collection, using the modern version of the
	  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
	  _.shuffle = function (obj) {
	    var set = isArrayLike(obj) ? obj : _.values(obj);
	    var length = set.length;
	    var shuffled = Array(length);
	    for (var index = 0, rand; index < length; index++) {
	      rand = _.random(0, index);
	      if (rand !== index) shuffled[index] = shuffled[rand];
	      shuffled[rand] = set[index];
	    }
	    return shuffled;
	  };

	  // Sample **n** random values from a collection.
	  // If **n** is not specified, returns a single random element.
	  // The internal `guard` argument allows it to work with `map`.
	  _.sample = function (obj, n, guard) {
	    if (n == null || guard) {
	      if (!isArrayLike(obj)) obj = _.values(obj);
	      return obj[_.random(obj.length - 1)];
	    }
	    return _.shuffle(obj).slice(0, Math.max(0, n));
	  };

	  // Sort the object's values by a criterion produced by an iteratee.
	  _.sortBy = function (obj, iteratee, context) {
	    iteratee = cb(iteratee, context);
	    return _.pluck(_.map(obj, function (value, index, list) {
	      return {
	        value: value,
	        index: index,
	        criteria: iteratee(value, index, list)
	      };
	    }).sort(function (left, right) {
	      var a = left.criteria;
	      var b = right.criteria;
	      if (a !== b) {
	        if (a > b || a === void 0) return 1;
	        if (a < b || b === void 0) return -1;
	      }
	      return left.index - right.index;
	    }), 'value');
	  };

	  // An internal function used for aggregate "group by" operations.
	  var group = function group(behavior) {
	    return function (obj, iteratee, context) {
	      var result = {};
	      iteratee = cb(iteratee, context);
	      _.each(obj, function (value, index) {
	        var key = iteratee(value, index, obj);
	        behavior(result, value, key);
	      });
	      return result;
	    };
	  };

	  // Groups the object's values by a criterion. Pass either a string attribute
	  // to group by, or a function that returns the criterion.
	  _.groupBy = group(function (result, value, key) {
	    if (_.has(result, key)) result[key].push(value);else result[key] = [value];
	  });

	  // Indexes the object's values by a criterion, similar to `groupBy`, but for
	  // when you know that your index values will be unique.
	  _.indexBy = group(function (result, value, key) {
	    result[key] = value;
	  });

	  // Counts instances of an object that group by a certain criterion. Pass
	  // either a string attribute to count by, or a function that returns the
	  // criterion.
	  _.countBy = group(function (result, value, key) {
	    if (_.has(result, key)) result[key]++;else result[key] = 1;
	  });

	  // Safely create a real, live array from anything iterable.
	  _.toArray = function (obj) {
	    if (!obj) return [];
	    if (_.isArray(obj)) return slice.call(obj);
	    if (isArrayLike(obj)) return _.map(obj, _.identity);
	    return _.values(obj);
	  };

	  // Return the number of elements in an object.
	  _.size = function (obj) {
	    if (obj == null) return 0;
	    return isArrayLike(obj) ? obj.length : _.keys(obj).length;
	  };

	  // Split a collection into two arrays: one whose elements all satisfy the given
	  // predicate, and one whose elements all do not satisfy the predicate.
	  _.partition = function (obj, predicate, context) {
	    predicate = cb(predicate, context);
	    var pass = [],
	        fail = [];
	    _.each(obj, function (value, key, obj) {
	      (predicate(value, key, obj) ? pass : fail).push(value);
	    });
	    return [pass, fail];
	  };

	  // Array Functions
	  // ---------------

	  // Get the first element of an array. Passing **n** will return the first N
	  // values in the array. Aliased as `head` and `take`. The **guard** check
	  // allows it to work with `_.map`.
	  _.first = _.head = _.take = function (array, n, guard) {
	    if (array == null) return void 0;
	    if (n == null || guard) return array[0];
	    return _.initial(array, array.length - n);
	  };

	  // Returns everything but the last entry of the array. Especially useful on
	  // the arguments object. Passing **n** will return all the values in
	  // the array, excluding the last N.
	  _.initial = function (array, n, guard) {
	    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
	  };

	  // Get the last element of an array. Passing **n** will return the last N
	  // values in the array.
	  _.last = function (array, n, guard) {
	    if (array == null) return void 0;
	    if (n == null || guard) return array[array.length - 1];
	    return _.rest(array, Math.max(0, array.length - n));
	  };

	  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
	  // Especially useful on the arguments object. Passing an **n** will return
	  // the rest N values in the array.
	  _.rest = _.tail = _.drop = function (array, n, guard) {
	    return slice.call(array, n == null || guard ? 1 : n);
	  };

	  // Trim out all falsy values from an array.
	  _.compact = function (array) {
	    return _.filter(array, _.identity);
	  };

	  // Internal implementation of a recursive `flatten` function.
	  var flatten = function flatten(input, shallow, strict, startIndex) {
	    var output = [],
	        idx = 0;
	    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {
	      var value = input[i];
	      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
	        //flatten current level of array or arguments object
	        if (!shallow) value = flatten(value, shallow, strict);
	        var j = 0,
	            len = value.length;
	        output.length += len;
	        while (j < len) {
	          output[idx++] = value[j++];
	        }
	      } else if (!strict) {
	        output[idx++] = value;
	      }
	    }
	    return output;
	  };

	  // Flatten out an array, either recursively (by default), or just one level.
	  _.flatten = function (array, shallow) {
	    return flatten(array, shallow, false);
	  };

	  // Return a version of the array that does not contain the specified value(s).
	  _.without = function (array) {
	    return _.difference(array, slice.call(arguments, 1));
	  };

	  // Produce a duplicate-free version of the array. If the array has already
	  // been sorted, you have the option of using a faster algorithm.
	  // Aliased as `unique`.
	  _.uniq = _.unique = function (array, isSorted, iteratee, context) {
	    if (!_.isBoolean(isSorted)) {
	      context = iteratee;
	      iteratee = isSorted;
	      isSorted = false;
	    }
	    if (iteratee != null) iteratee = cb(iteratee, context);
	    var result = [];
	    var seen = [];
	    for (var i = 0, length = getLength(array); i < length; i++) {
	      var value = array[i],
	          computed = iteratee ? iteratee(value, i, array) : value;
	      if (isSorted) {
	        if (!i || seen !== computed) result.push(value);
	        seen = computed;
	      } else if (iteratee) {
	        if (!_.contains(seen, computed)) {
	          seen.push(computed);
	          result.push(value);
	        }
	      } else if (!_.contains(result, value)) {
	        result.push(value);
	      }
	    }
	    return result;
	  };

	  // Produce an array that contains the union: each distinct element from all of
	  // the passed-in arrays.
	  _.union = function () {
	    return _.uniq(flatten(arguments, true, true));
	  };

	  // Produce an array that contains every item shared between all the
	  // passed-in arrays.
	  _.intersection = function (array) {
	    var result = [];
	    var argsLength = arguments.length;
	    for (var i = 0, length = getLength(array); i < length; i++) {
	      var item = array[i];
	      if (_.contains(result, item)) continue;
	      for (var j = 1; j < argsLength; j++) {
	        if (!_.contains(arguments[j], item)) break;
	      }
	      if (j === argsLength) result.push(item);
	    }
	    return result;
	  };

	  // Take the difference between one array and a number of other arrays.
	  // Only the elements present in just the first array will remain.
	  _.difference = function (array) {
	    var rest = flatten(arguments, true, true, 1);
	    return _.filter(array, function (value) {
	      return !_.contains(rest, value);
	    });
	  };

	  // Zip together multiple lists into a single array -- elements that share
	  // an index go together.
	  _.zip = function () {
	    return _.unzip(arguments);
	  };

	  // Complement of _.zip. Unzip accepts an array of arrays and groups
	  // each array's elements on shared indices
	  _.unzip = function (array) {
	    var length = array && _.max(array, getLength).length || 0;
	    var result = Array(length);

	    for (var index = 0; index < length; index++) {
	      result[index] = _.pluck(array, index);
	    }
	    return result;
	  };

	  // Converts lists into objects. Pass either a single array of `[key, value]`
	  // pairs, or two parallel arrays of the same length -- one of keys, and one of
	  // the corresponding values.
	  _.object = function (list, values) {
	    var result = {};
	    for (var i = 0, length = getLength(list); i < length; i++) {
	      if (values) {
	        result[list[i]] = values[i];
	      } else {
	        result[list[i][0]] = list[i][1];
	      }
	    }
	    return result;
	  };

	  // Generator function to create the findIndex and findLastIndex functions
	  function createPredicateIndexFinder(dir) {
	    return function (array, predicate, context) {
	      predicate = cb(predicate, context);
	      var length = getLength(array);
	      var index = dir > 0 ? 0 : length - 1;
	      for (; index >= 0 && index < length; index += dir) {
	        if (predicate(array[index], index, array)) return index;
	      }
	      return -1;
	    };
	  }

	  // Returns the first index on an array-like that passes a predicate test
	  _.findIndex = createPredicateIndexFinder(1);
	  _.findLastIndex = createPredicateIndexFinder(-1);

	  // Use a comparator function to figure out the smallest index at which
	  // an object should be inserted so as to maintain order. Uses binary search.
	  _.sortedIndex = function (array, obj, iteratee, context) {
	    iteratee = cb(iteratee, context, 1);
	    var value = iteratee(obj);
	    var low = 0,
	        high = getLength(array);
	    while (low < high) {
	      var mid = Math.floor((low + high) / 2);
	      if (iteratee(array[mid]) < value) low = mid + 1;else high = mid;
	    }
	    return low;
	  };

	  // Generator function to create the indexOf and lastIndexOf functions
	  function createIndexFinder(dir, predicateFind, sortedIndex) {
	    return function (array, item, idx) {
	      var i = 0,
	          length = getLength(array);
	      if (typeof idx == 'number') {
	        if (dir > 0) {
	          i = idx >= 0 ? idx : Math.max(idx + length, i);
	        } else {
	          length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
	        }
	      } else if (sortedIndex && idx && length) {
	        idx = sortedIndex(array, item);
	        return array[idx] === item ? idx : -1;
	      }
	      if (item !== item) {
	        idx = predicateFind(slice.call(array, i, length), _.isNaN);
	        return idx >= 0 ? idx + i : -1;
	      }
	      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
	        if (array[idx] === item) return idx;
	      }
	      return -1;
	    };
	  }

	  // Return the position of the first occurrence of an item in an array,
	  // or -1 if the item is not included in the array.
	  // If the array is large and already in sort order, pass `true`
	  // for **isSorted** to use binary search.
	  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
	  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);

	  // Generate an integer Array containing an arithmetic progression. A port of
	  // the native Python `range()` function. See
	  // [the Python documentation](http://docs.python.org/library/functions.html#range).
	  _.range = function (start, stop, step) {
	    if (stop == null) {
	      stop = start || 0;
	      start = 0;
	    }
	    step = step || 1;

	    var length = Math.max(Math.ceil((stop - start) / step), 0);
	    var range = Array(length);

	    for (var idx = 0; idx < length; idx++, start += step) {
	      range[idx] = start;
	    }

	    return range;
	  };

	  // Function (ahem) Functions
	  // ------------------

	  // Determines whether to execute a function as a constructor
	  // or a normal function with the provided arguments
	  var executeBound = function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
	    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
	    var self = baseCreate(sourceFunc.prototype);
	    var result = sourceFunc.apply(self, args);
	    if (_.isObject(result)) return result;
	    return self;
	  };

	  // Create a function bound to a given object (assigning `this`, and arguments,
	  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
	  // available.
	  _.bind = function (func, context) {
	    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
	    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
	    var args = slice.call(arguments, 2);
	    var bound = function bound() {
	      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
	    };
	    return bound;
	  };

	  // Partially apply a function by creating a version that has had some of its
	  // arguments pre-filled, without changing its dynamic `this` context. _ acts
	  // as a placeholder, allowing any combination of arguments to be pre-filled.
	  _.partial = function (func) {
	    var boundArgs = slice.call(arguments, 1);
	    var bound = function bound() {
	      var position = 0,
	          length = boundArgs.length;
	      var args = Array(length);
	      for (var i = 0; i < length; i++) {
	        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
	      }
	      while (position < arguments.length) {
	        args.push(arguments[position++]);
	      }return executeBound(func, bound, this, this, args);
	    };
	    return bound;
	  };

	  // Bind a number of an object's methods to that object. Remaining arguments
	  // are the method names to be bound. Useful for ensuring that all callbacks
	  // defined on an object belong to it.
	  _.bindAll = function (obj) {
	    var i,
	        length = arguments.length,
	        key;
	    if (length <= 1) throw new Error('bindAll must be passed function names');
	    for (i = 1; i < length; i++) {
	      key = arguments[i];
	      obj[key] = _.bind(obj[key], obj);
	    }
	    return obj;
	  };

	  // Memoize an expensive function by storing its results.
	  _.memoize = function (func, hasher) {
	    var memoize = function memoize(key) {
	      var cache = memoize.cache;
	      var address = '' + (hasher ? hasher.apply(this, arguments) : key);
	      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
	      return cache[address];
	    };
	    memoize.cache = {};
	    return memoize;
	  };

	  // Delays a function for the given number of milliseconds, and then calls
	  // it with the arguments supplied.
	  _.delay = function (func, wait) {
	    var args = slice.call(arguments, 2);
	    return setTimeout(function () {
	      return func.apply(null, args);
	    }, wait);
	  };

	  // Defers a function, scheduling it to run after the current call stack has
	  // cleared.
	  _.defer = _.partial(_.delay, _, 1);

	  // Returns a function, that, when invoked, will only be triggered at most once
	  // during a given window of time. Normally, the throttled function will run
	  // as much as it can, without ever going more than once per `wait` duration;
	  // but if you'd like to disable the execution on the leading edge, pass
	  // `{leading: false}`. To disable execution on the trailing edge, ditto.
	  _.throttle = function (func, wait, options) {
	    var context, args, result;
	    var timeout = null;
	    var previous = 0;
	    if (!options) options = {};
	    var later = function later() {
	      previous = options.leading === false ? 0 : _.now();
	      timeout = null;
	      result = func.apply(context, args);
	      if (!timeout) context = args = null;
	    };
	    return function () {
	      var now = _.now();
	      if (!previous && options.leading === false) previous = now;
	      var remaining = wait - (now - previous);
	      context = this;
	      args = arguments;
	      if (remaining <= 0 || remaining > wait) {
	        if (timeout) {
	          clearTimeout(timeout);
	          timeout = null;
	        }
	        previous = now;
	        result = func.apply(context, args);
	        if (!timeout) context = args = null;
	      } else if (!timeout && options.trailing !== false) {
	        timeout = setTimeout(later, remaining);
	      }
	      return result;
	    };
	  };

	  // Returns a function, that, as long as it continues to be invoked, will not
	  // be triggered. The function will be called after it stops being called for
	  // N milliseconds. If `immediate` is passed, trigger the function on the
	  // leading edge, instead of the trailing.
	  _.debounce = function (func, wait, immediate) {
	    var timeout, args, context, timestamp, result;

	    var later = function later() {
	      var last = _.now() - timestamp;

	      if (last < wait && last >= 0) {
	        timeout = setTimeout(later, wait - last);
	      } else {
	        timeout = null;
	        if (!immediate) {
	          result = func.apply(context, args);
	          if (!timeout) context = args = null;
	        }
	      }
	    };

	    return function () {
	      context = this;
	      args = arguments;
	      timestamp = _.now();
	      var callNow = immediate && !timeout;
	      if (!timeout) timeout = setTimeout(later, wait);
	      if (callNow) {
	        result = func.apply(context, args);
	        context = args = null;
	      }

	      return result;
	    };
	  };

	  // Returns the first function passed as an argument to the second,
	  // allowing you to adjust arguments, run code before and after, and
	  // conditionally execute the original function.
	  _.wrap = function (func, wrapper) {
	    return _.partial(wrapper, func);
	  };

	  // Returns a negated version of the passed-in predicate.
	  _.negate = function (predicate) {
	    return function () {
	      return !predicate.apply(this, arguments);
	    };
	  };

	  // Returns a function that is the composition of a list of functions, each
	  // consuming the return value of the function that follows.
	  _.compose = function () {
	    var args = arguments;
	    var start = args.length - 1;
	    return function () {
	      var i = start;
	      var result = args[start].apply(this, arguments);
	      while (i--) {
	        result = args[i].call(this, result);
	      }return result;
	    };
	  };

	  // Returns a function that will only be executed on and after the Nth call.
	  _.after = function (times, func) {
	    return function () {
	      if (--times < 1) {
	        return func.apply(this, arguments);
	      }
	    };
	  };

	  // Returns a function that will only be executed up to (but not including) the Nth call.
	  _.before = function (times, func) {
	    var memo;
	    return function () {
	      if (--times > 0) {
	        memo = func.apply(this, arguments);
	      }
	      if (times <= 1) func = null;
	      return memo;
	    };
	  };

	  // Returns a function that will be executed at most one time, no matter how
	  // often you call it. Useful for lazy initialization.
	  _.once = _.partial(_.before, 2);

	  // Object Functions
	  // ----------------

	  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
	  var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');
	  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

	  function collectNonEnumProps(obj, keys) {
	    var nonEnumIdx = nonEnumerableProps.length;
	    var constructor = obj.constructor;
	    var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;

	    // Constructor is a special case.
	    var prop = 'constructor';
	    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);

	    while (nonEnumIdx--) {
	      prop = nonEnumerableProps[nonEnumIdx];
	      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
	        keys.push(prop);
	      }
	    }
	  }

	  // Retrieve the names of an object's own properties.
	  // Delegates to **ECMAScript 5**'s native `Object.keys`
	  _.keys = function (obj) {
	    if (!_.isObject(obj)) return [];
	    if (nativeKeys) return nativeKeys(obj);
	    var keys = [];
	    for (var key in obj) {
	      if (_.has(obj, key)) keys.push(key);
	    } // Ahem, IE < 9.
	    if (hasEnumBug) collectNonEnumProps(obj, keys);
	    return keys;
	  };

	  // Retrieve all the property names of an object.
	  _.allKeys = function (obj) {
	    if (!_.isObject(obj)) return [];
	    var keys = [];
	    for (var key in obj) {
	      keys.push(key);
	    } // Ahem, IE < 9.
	    if (hasEnumBug) collectNonEnumProps(obj, keys);
	    return keys;
	  };

	  // Retrieve the values of an object's properties.
	  _.values = function (obj) {
	    var keys = _.keys(obj);
	    var length = keys.length;
	    var values = Array(length);
	    for (var i = 0; i < length; i++) {
	      values[i] = obj[keys[i]];
	    }
	    return values;
	  };

	  // Returns the results of applying the iteratee to each element of the object
	  // In contrast to _.map it returns an object
	  _.mapObject = function (obj, iteratee, context) {
	    iteratee = cb(iteratee, context);
	    var keys = _.keys(obj),
	        length = keys.length,
	        results = {},
	        currentKey;
	    for (var index = 0; index < length; index++) {
	      currentKey = keys[index];
	      results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
	    }
	    return results;
	  };

	  // Convert an object into a list of `[key, value]` pairs.
	  _.pairs = function (obj) {
	    var keys = _.keys(obj);
	    var length = keys.length;
	    var pairs = Array(length);
	    for (var i = 0; i < length; i++) {
	      pairs[i] = [keys[i], obj[keys[i]]];
	    }
	    return pairs;
	  };

	  // Invert the keys and values of an object. The values must be serializable.
	  _.invert = function (obj) {
	    var result = {};
	    var keys = _.keys(obj);
	    for (var i = 0, length = keys.length; i < length; i++) {
	      result[obj[keys[i]]] = keys[i];
	    }
	    return result;
	  };

	  // Return a sorted list of the function names available on the object.
	  // Aliased as `methods`
	  _.functions = _.methods = function (obj) {
	    var names = [];
	    for (var key in obj) {
	      if (_.isFunction(obj[key])) names.push(key);
	    }
	    return names.sort();
	  };

	  // Extend a given object with all the properties in passed-in object(s).
	  _.extend = createAssigner(_.allKeys);

	  // Assigns a given object with all the own properties in the passed-in object(s)
	  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
	  _.extendOwn = _.assign = createAssigner(_.keys);

	  // Returns the first key on an object that passes a predicate test
	  _.findKey = function (obj, predicate, context) {
	    predicate = cb(predicate, context);
	    var keys = _.keys(obj),
	        key;
	    for (var i = 0, length = keys.length; i < length; i++) {
	      key = keys[i];
	      if (predicate(obj[key], key, obj)) return key;
	    }
	  };

	  // Return a copy of the object only containing the whitelisted properties.
	  _.pick = function (object, oiteratee, context) {
	    var result = {},
	        obj = object,
	        iteratee,
	        keys;
	    if (obj == null) return result;
	    if (_.isFunction(oiteratee)) {
	      keys = _.allKeys(obj);
	      iteratee = optimizeCb(oiteratee, context);
	    } else {
	      keys = flatten(arguments, false, false, 1);
	      iteratee = function iteratee(value, key, obj) {
	        return key in obj;
	      };
	      obj = Object(obj);
	    }
	    for (var i = 0, length = keys.length; i < length; i++) {
	      var key = keys[i];
	      var value = obj[key];
	      if (iteratee(value, key, obj)) result[key] = value;
	    }
	    return result;
	  };

	  // Return a copy of the object without the blacklisted properties.
	  _.omit = function (obj, iteratee, context) {
	    if (_.isFunction(iteratee)) {
	      iteratee = _.negate(iteratee);
	    } else {
	      var keys = _.map(flatten(arguments, false, false, 1), String);
	      iteratee = function iteratee(value, key) {
	        return !_.contains(keys, key);
	      };
	    }
	    return _.pick(obj, iteratee, context);
	  };

	  // Fill in a given object with default properties.
	  _.defaults = createAssigner(_.allKeys, true);

	  // Creates an object that inherits from the given prototype object.
	  // If additional properties are provided then they will be added to the
	  // created object.
	  _.create = function (prototype, props) {
	    var result = baseCreate(prototype);
	    if (props) _.extendOwn(result, props);
	    return result;
	  };

	  // Create a (shallow-cloned) duplicate of an object.
	  _.clone = function (obj) {
	    if (!_.isObject(obj)) return obj;
	    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
	  };

	  // Invokes interceptor with the obj, and then returns obj.
	  // The primary purpose of this method is to "tap into" a method chain, in
	  // order to perform operations on intermediate results within the chain.
	  _.tap = function (obj, interceptor) {
	    interceptor(obj);
	    return obj;
	  };

	  // Returns whether an object has a given set of `key:value` pairs.
	  _.isMatch = function (object, attrs) {
	    var keys = _.keys(attrs),
	        length = keys.length;
	    if (object == null) return !length;
	    var obj = Object(object);
	    for (var i = 0; i < length; i++) {
	      var key = keys[i];
	      if (attrs[key] !== obj[key] || !(key in obj)) return false;
	    }
	    return true;
	  };

	  // Internal recursive comparison function for `isEqual`.
	  var eq = function eq(a, b, aStack, bStack) {
	    // Identical objects are equal. `0 === -0`, but they aren't identical.
	    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
	    if (a === b) return a !== 0 || 1 / a === 1 / b;
	    // A strict comparison is necessary because `null == undefined`.
	    if (a == null || b == null) return a === b;
	    // Unwrap any wrapped objects.
	    if (a instanceof _) a = a._wrapped;
	    if (b instanceof _) b = b._wrapped;
	    // Compare `[[Class]]` names.
	    var className = toString.call(a);
	    if (className !== toString.call(b)) return false;
	    switch (className) {
	      // Strings, numbers, regular expressions, dates, and booleans are compared by value.
	      case '[object RegExp]':
	      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
	      case '[object String]':
	        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
	        // equivalent to `new String("5")`.
	        return '' + a === '' + b;
	      case '[object Number]':
	        // `NaN`s are equivalent, but non-reflexive.
	        // Object(NaN) is equivalent to NaN
	        if (+a !== +a) return +b !== +b;
	        // An `egal` comparison is performed for other numeric values.
	        return +a === 0 ? 1 / +a === 1 / b : +a === +b;
	      case '[object Date]':
	      case '[object Boolean]':
	        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
	        // millisecond representations. Note that invalid dates with millisecond representations
	        // of `NaN` are not equivalent.
	        return +a === +b;
	    }

	    var areArrays = className === '[object Array]';
	    if (!areArrays) {
	      if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) != 'object' || (typeof b === 'undefined' ? 'undefined' : _typeof(b)) != 'object') return false;

	      // Objects with different constructors are not equivalent, but `Object`s or `Array`s
	      // from different frames are.
	      var aCtor = a.constructor,
	          bCtor = b.constructor;
	      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && _.isFunction(bCtor) && bCtor instanceof bCtor) && 'constructor' in a && 'constructor' in b) {
	        return false;
	      }
	    }
	    // Assume equality for cyclic structures. The algorithm for detecting cyclic
	    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.

	    // Initializing stack of traversed objects.
	    // It's done here since we only need them for objects and arrays comparison.
	    aStack = aStack || [];
	    bStack = bStack || [];
	    var length = aStack.length;
	    while (length--) {
	      // Linear search. Performance is inversely proportional to the number of
	      // unique nested structures.
	      if (aStack[length] === a) return bStack[length] === b;
	    }

	    // Add the first object to the stack of traversed objects.
	    aStack.push(a);
	    bStack.push(b);

	    // Recursively compare objects and arrays.
	    if (areArrays) {
	      // Compare array lengths to determine if a deep comparison is necessary.
	      length = a.length;
	      if (length !== b.length) return false;
	      // Deep compare the contents, ignoring non-numeric properties.
	      while (length--) {
	        if (!eq(a[length], b[length], aStack, bStack)) return false;
	      }
	    } else {
	      // Deep compare objects.
	      var keys = _.keys(a),
	          key;
	      length = keys.length;
	      // Ensure that both objects contain the same number of properties before comparing deep equality.
	      if (_.keys(b).length !== length) return false;
	      while (length--) {
	        // Deep compare each member
	        key = keys[length];
	        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
	      }
	    }
	    // Remove the first object from the stack of traversed objects.
	    aStack.pop();
	    bStack.pop();
	    return true;
	  };

	  // Perform a deep comparison to check if two objects are equal.
	  _.isEqual = function (a, b) {
	    return eq(a, b);
	  };

	  // Is a given array, string, or object empty?
	  // An "empty" object has no enumerable own-properties.
	  _.isEmpty = function (obj) {
	    if (obj == null) return true;
	    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;
	    return _.keys(obj).length === 0;
	  };

	  // Is a given value a DOM element?
	  _.isElement = function (obj) {
	    return !!(obj && obj.nodeType === 1);
	  };

	  // Is a given value an array?
	  // Delegates to ECMA5's native Array.isArray
	  _.isArray = nativeIsArray || function (obj) {
	    return toString.call(obj) === '[object Array]';
	  };

	  // Is a given variable an object?
	  _.isObject = function (obj) {
	    var type = typeof obj === 'undefined' ? 'undefined' : _typeof(obj);
	    return type === 'function' || type === 'object' && !!obj;
	  };

	  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.
	  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function (name) {
	    _['is' + name] = function (obj) {
	      return toString.call(obj) === '[object ' + name + ']';
	    };
	  });

	  // Define a fallback version of the method in browsers (ahem, IE < 9), where
	  // there isn't any inspectable "Arguments" type.
	  if (!_.isArguments(arguments)) {
	    _.isArguments = function (obj) {
	      return _.has(obj, 'callee');
	    };
	  }

	  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
	  // IE 11 (#1621), and in Safari 8 (#1929).
	  if (typeof /./ != 'function' && (typeof Int8Array === 'undefined' ? 'undefined' : _typeof(Int8Array)) != 'object') {
	    _.isFunction = function (obj) {
	      return typeof obj == 'function' || false;
	    };
	  }

	  // Is a given object a finite number?
	  _.isFinite = function (obj) {
	    return isFinite(obj) && !isNaN(parseFloat(obj));
	  };

	  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
	  _.isNaN = function (obj) {
	    return _.isNumber(obj) && obj !== +obj;
	  };

	  // Is a given value a boolean?
	  _.isBoolean = function (obj) {
	    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
	  };

	  // Is a given value equal to null?
	  _.isNull = function (obj) {
	    return obj === null;
	  };

	  // Is a given variable undefined?
	  _.isUndefined = function (obj) {
	    return obj === void 0;
	  };

	  // Shortcut function for checking if an object has a given property directly
	  // on itself (in other words, not on a prototype).
	  _.has = function (obj, key) {
	    return obj != null && hasOwnProperty.call(obj, key);
	  };

	  // Utility Functions
	  // -----------------

	  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
	  // previous owner. Returns a reference to the Underscore object.
	  _.noConflict = function () {
	    root._ = previousUnderscore;
	    return this;
	  };

	  // Keep the identity function around for default iteratees.
	  _.identity = function (value) {
	    return value;
	  };

	  // Predicate-generating functions. Often useful outside of Underscore.
	  _.constant = function (value) {
	    return function () {
	      return value;
	    };
	  };

	  _.noop = function () {};

	  _.property = property;

	  // Generates a function for a given object that returns a given property.
	  _.propertyOf = function (obj) {
	    return obj == null ? function () {} : function (key) {
	      return obj[key];
	    };
	  };

	  // Returns a predicate for checking whether an object has a given set of
	  // `key:value` pairs.
	  _.matcher = _.matches = function (attrs) {
	    attrs = _.extendOwn({}, attrs);
	    return function (obj) {
	      return _.isMatch(obj, attrs);
	    };
	  };

	  // Run a function **n** times.
	  _.times = function (n, iteratee, context) {
	    var accum = Array(Math.max(0, n));
	    iteratee = optimizeCb(iteratee, context, 1);
	    for (var i = 0; i < n; i++) {
	      accum[i] = iteratee(i);
	    }return accum;
	  };

	  // Return a random integer between min and max (inclusive).
	  _.random = function (min, max) {
	    if (max == null) {
	      max = min;
	      min = 0;
	    }
	    return min + Math.floor(Math.random() * (max - min + 1));
	  };

	  // A (possibly faster) way to get the current timestamp as an integer.
	  _.now = Date.now || function () {
	    return new Date().getTime();
	  };

	  // List of HTML entities for escaping.
	  var escapeMap = {
	    '&': '&amp;',
	    '<': '&lt;',
	    '>': '&gt;',
	    '"': '&quot;',
	    "'": '&#x27;',
	    '`': '&#x60;'
	  };
	  var unescapeMap = _.invert(escapeMap);

	  // Functions for escaping and unescaping strings to/from HTML interpolation.
	  var createEscaper = function createEscaper(map) {
	    var escaper = function escaper(match) {
	      return map[match];
	    };
	    // Regexes for identifying a key that needs to be escaped
	    var source = '(?:' + _.keys(map).join('|') + ')';
	    var testRegexp = RegExp(source);
	    var replaceRegexp = RegExp(source, 'g');
	    return function (string) {
	      string = string == null ? '' : '' + string;
	      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
	    };
	  };
	  _.escape = createEscaper(escapeMap);
	  _.unescape = createEscaper(unescapeMap);

	  // If the value of the named `property` is a function then invoke it with the
	  // `object` as context; otherwise, return it.
	  _.result = function (object, property, fallback) {
	    var value = object == null ? void 0 : object[property];
	    if (value === void 0) {
	      value = fallback;
	    }
	    return _.isFunction(value) ? value.call(object) : value;
	  };

	  // Generate a unique integer id (unique within the entire client session).
	  // Useful for temporary DOM ids.
	  var idCounter = 0;
	  _.uniqueId = function (prefix) {
	    var id = ++idCounter + '';
	    return prefix ? prefix + id : id;
	  };

	  // By default, Underscore uses ERB-style template delimiters, change the
	  // following template settings to use alternative delimiters.
	  _.templateSettings = {
	    evaluate: /<%([\s\S]+?)%>/g,
	    interpolate: /<%=([\s\S]+?)%>/g,
	    escape: /<%-([\s\S]+?)%>/g
	  };

	  // When customizing `templateSettings`, if you don't want to define an
	  // interpolation, evaluation or escaping regex, we need one that is
	  // guaranteed not to match.
	  var noMatch = /(.)^/;

	  // Certain characters need to be escaped so that they can be put into a
	  // string literal.
	  var escapes = {
	    "'": "'",
	    '\\': '\\',
	    '\r': 'r',
	    '\n': 'n',
	    '\u2028': 'u2028',
	    '\u2029': 'u2029'
	  };

	  var escaper = /\\|'|\r|\n|\u2028|\u2029/g;

	  var escapeChar = function escapeChar(match) {
	    return '\\' + escapes[match];
	  };

	  // JavaScript micro-templating, similar to John Resig's implementation.
	  // Underscore templating handles arbitrary delimiters, preserves whitespace,
	  // and correctly escapes quotes within interpolated code.
	  // NB: `oldSettings` only exists for backwards compatibility.
	  _.template = function (text, settings, oldSettings) {
	    if (!settings && oldSettings) settings = oldSettings;
	    settings = _.defaults({}, settings, _.templateSettings);

	    // Combine delimiters into one regular expression via alternation.
	    var matcher = RegExp([(settings.escape || noMatch).source, (settings.interpolate || noMatch).source, (settings.evaluate || noMatch).source].join('|') + '|$', 'g');

	    // Compile the template source, escaping string literals appropriately.
	    var index = 0;
	    var source = "__p+='";
	    text.replace(matcher, function (match, escape, interpolate, evaluate, offset) {
	      source += text.slice(index, offset).replace(escaper, escapeChar);
	      index = offset + match.length;

	      if (escape) {
	        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
	      } else if (interpolate) {
	        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
	      } else if (evaluate) {
	        source += "';\n" + evaluate + "\n__p+='";
	      }

	      // Adobe VMs need the match returned to produce the correct offest.
	      return match;
	    });
	    source += "';\n";

	    // If a variable is not specified, place data values in local scope.
	    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

	    source = "var __t,__p='',__j=Array.prototype.join," + "print=function(){__p+=__j.call(arguments,'');};\n" + source + 'return __p;\n';

	    try {
	      var render = new Function(settings.variable || 'obj', '_', source);
	    } catch (e) {
	      e.source = source;
	      throw e;
	    }

	    var template = function template(data) {
	      return render.call(this, data, _);
	    };

	    // Provide the compiled source as a convenience for precompilation.
	    var argument = settings.variable || 'obj';
	    template.source = 'function(' + argument + '){\n' + source + '}';

	    return template;
	  };

	  // Add a "chain" function. Start chaining a wrapped Underscore object.
	  _.chain = function (obj) {
	    var instance = _(obj);
	    instance._chain = true;
	    return instance;
	  };

	  // OOP
	  // ---------------
	  // If Underscore is called as a function, it returns a wrapped object that
	  // can be used OO-style. This wrapper holds altered versions of all the
	  // underscore functions. Wrapped objects may be chained.

	  // Helper function to continue chaining intermediate results.
	  var result = function result(instance, obj) {
	    return instance._chain ? _(obj).chain() : obj;
	  };

	  // Add your own custom functions to the Underscore object.
	  _.mixin = function (obj) {
	    _.each(_.functions(obj), function (name) {
	      var func = _[name] = obj[name];
	      _.prototype[name] = function () {
	        var args = [this._wrapped];
	        push.apply(args, arguments);
	        return result(this, func.apply(_, args));
	      };
	    });
	  };

	  // Add all of the Underscore functions to the wrapper object.
	  _.mixin(_);

	  // Add all mutator Array functions to the wrapper.
	  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (name) {
	    var method = ArrayProto[name];
	    _.prototype[name] = function () {
	      var obj = this._wrapped;
	      method.apply(obj, arguments);
	      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
	      return result(this, obj);
	    };
	  });

	  // Add all accessor Array functions to the wrapper.
	  _.each(['concat', 'join', 'slice'], function (name) {
	    var method = ArrayProto[name];
	    _.prototype[name] = function () {
	      return result(this, method.apply(this._wrapped, arguments));
	    };
	  });

	  // Extracts the result from a wrapped and chained object.
	  _.prototype.value = function () {
	    return this._wrapped;
	  };

	  // Provide unwrapping proxy for some methods used in engine operations
	  // such as arithmetic and JSON stringification.
	  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;

	  _.prototype.toString = function () {
	    return '' + this._wrapped;
	  };

	  // AMD registration happens at the end for compatibility with AMD loaders
	  // that may not enforce next-turn semantics on modules. Even though general
	  // practice for AMD registration is to be anonymous, underscore registers
	  // as a named module because, like jQuery, it is a base library that is
	  // popular enough to be bundled in a third party lib, but not be part of
	  // an AMD load request. Those cases could generate an error when an
	  // anonymous define() is called outside of a loader request.
	  if (true) {
	    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return _;
	    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  }
	}).call(undefined);

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {"use strict";var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol?"symbol":typeof obj;};/*!
	 * jQuery JavaScript Library v3.0.0
	 * https://jquery.com/
	 *
	 * Includes Sizzle.js
	 * https://sizzlejs.com/
	 *
	 * Copyright jQuery Foundation and other contributors
	 * Released under the MIT license
	 * https://jquery.org/license
	 *
	 * Date: 2016-06-09T18:02Z
	 */(function(global,factory){"use strict";if(( false?"undefined":_typeof(module))==="object"&&_typeof(module.exports)==="object"){// For CommonJS and CommonJS-like environments where a proper `window`
	// is present, execute the factory and get jQuery.
	// For environments that do not have a `window` with a `document`
	// (such as Node.js), expose a factory as module.exports.
	// This accentuates the need for the creation of a real `window`.
	// e.g. var jQuery = require("jquery")(window);
	// See ticket #14549 for more info.
	module.exports=global.document?factory(global,true):function(w){if(!w.document){throw new Error("jQuery requires a window with a document");}return factory(w);};}else{factory(global);}// Pass this if window is not defined yet
	})(typeof window!=="undefined"?window:undefined,function(window,noGlobal){// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
	// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
	// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
	// enough that all such attempts are guarded in a try block.
	"use strict";var arr=[];var document=window.document;var getProto=Object.getPrototypeOf;var _slice=arr.slice;var concat=arr.concat;var push=arr.push;var indexOf=arr.indexOf;var class2type={};var toString=class2type.toString;var hasOwn=class2type.hasOwnProperty;var fnToString=hasOwn.toString;var ObjectFunctionString=fnToString.call(Object);var support={};function DOMEval(code,doc){doc=doc||document;var script=doc.createElement("script");script.text=code;doc.head.appendChild(script).parentNode.removeChild(script);}var version="3.0.0",// Define a local copy of jQuery
	jQuery=function jQuery(selector,context){// The jQuery object is actually just the init constructor 'enhanced'
	// Need init if jQuery is called (just allow error to be thrown if not included)
	return new jQuery.fn.init(selector,context);},// Support: Android <=4.0 only
	// Make sure we trim BOM and NBSP
	rtrim=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,// Matches dashed string for camelizing
	rmsPrefix=/^-ms-/,rdashAlpha=/-([a-z])/g,// Used by jQuery.camelCase as callback to replace()
	fcamelCase=function fcamelCase(all,letter){return letter.toUpperCase();};jQuery.fn=jQuery.prototype={// The current version of jQuery being used
	jquery:version,constructor:jQuery,// The default length of a jQuery object is 0
	length:0,toArray:function toArray(){return _slice.call(this);},// Get the Nth element in the matched element set OR
	// Get the whole matched element set as a clean array
	get:function get(num){return num!=null?// Return just the one element from the set
	num<0?this[num+this.length]:this[num]:// Return all the elements in a clean array
	_slice.call(this);},// Take an array of elements and push it onto the stack
	// (returning the new matched element set)
	pushStack:function pushStack(elems){// Build a new jQuery matched element set
	var ret=jQuery.merge(this.constructor(),elems);// Add the old object onto the stack (as a reference)
	ret.prevObject=this;// Return the newly-formed element set
	return ret;},// Execute a callback for every element in the matched set.
	each:function each(callback){return jQuery.each(this,callback);},map:function map(callback){return this.pushStack(jQuery.map(this,function(elem,i){return callback.call(elem,i,elem);}));},slice:function slice(){return this.pushStack(_slice.apply(this,arguments));},first:function first(){return this.eq(0);},last:function last(){return this.eq(-1);},eq:function eq(i){var len=this.length,j=+i+(i<0?len:0);return this.pushStack(j>=0&&j<len?[this[j]]:[]);},end:function end(){return this.prevObject||this.constructor();},// For internal use only.
	// Behaves like an Array's method, not like a jQuery method.
	push:push,sort:arr.sort,splice:arr.splice};jQuery.extend=jQuery.fn.extend=function(){var options,name,src,copy,copyIsArray,clone,target=arguments[0]||{},i=1,length=arguments.length,deep=false;// Handle a deep copy situation
	if(typeof target==="boolean"){deep=target;// Skip the boolean and the target
	target=arguments[i]||{};i++;}// Handle case when target is a string or something (possible in deep copy)
	if((typeof target==="undefined"?"undefined":_typeof(target))!=="object"&&!jQuery.isFunction(target)){target={};}// Extend jQuery itself if only one argument is passed
	if(i===length){target=this;i--;}for(;i<length;i++){// Only deal with non-null/undefined values
	if((options=arguments[i])!=null){// Extend the base object
	for(name in options){src=target[name];copy=options[name];// Prevent never-ending loop
	if(target===copy){continue;}// Recurse if we're merging plain objects or arrays
	if(deep&&copy&&(jQuery.isPlainObject(copy)||(copyIsArray=jQuery.isArray(copy)))){if(copyIsArray){copyIsArray=false;clone=src&&jQuery.isArray(src)?src:[];}else{clone=src&&jQuery.isPlainObject(src)?src:{};}// Never move original objects, clone them
	target[name]=jQuery.extend(deep,clone,copy);// Don't bring in undefined values
	}else if(copy!==undefined){target[name]=copy;}}}}// Return the modified object
	return target;};jQuery.extend({// Unique for each copy of jQuery on the page
	expando:"jQuery"+(version+Math.random()).replace(/\D/g,""),// Assume jQuery is ready without the ready module
	isReady:true,error:function error(msg){throw new Error(msg);},noop:function noop(){},isFunction:function isFunction(obj){return jQuery.type(obj)==="function";},isArray:Array.isArray,isWindow:function isWindow(obj){return obj!=null&&obj===obj.window;},isNumeric:function isNumeric(obj){// As of jQuery 3.0, isNumeric is limited to
	// strings and numbers (primitives or objects)
	// that can be coerced to finite numbers (gh-2662)
	var type=jQuery.type(obj);return(type==="number"||type==="string")&&// parseFloat NaNs numeric-cast false positives ("")
	// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
	// subtraction forces infinities to NaN
	!isNaN(obj-parseFloat(obj));},isPlainObject:function isPlainObject(obj){var proto,Ctor;// Detect obvious negatives
	// Use toString instead of jQuery.type to catch host objects
	if(!obj||toString.call(obj)!=="[object Object]"){return false;}proto=getProto(obj);// Objects with no prototype (e.g., `Object.create( null )`) are plain
	if(!proto){return true;}// Objects with prototype are plain iff they were constructed by a global Object function
	Ctor=hasOwn.call(proto,"constructor")&&proto.constructor;return typeof Ctor==="function"&&fnToString.call(Ctor)===ObjectFunctionString;},isEmptyObject:function isEmptyObject(obj){var name;for(name in obj){return false;}return true;},type:function type(obj){if(obj==null){return obj+"";}// Support: Android <=2.3 only (functionish RegExp)
	return(typeof obj==="undefined"?"undefined":_typeof(obj))==="object"||typeof obj==="function"?class2type[toString.call(obj)]||"object":typeof obj==="undefined"?"undefined":_typeof(obj);},// Evaluates a script in a global context
	globalEval:function globalEval(code){DOMEval(code);},// Convert dashed to camelCase; used by the css and data modules
	// Support: IE <=9 - 11, Edge 12 - 13
	// Microsoft forgot to hump their vendor prefix (#9572)
	camelCase:function camelCase(string){return string.replace(rmsPrefix,"ms-").replace(rdashAlpha,fcamelCase);},nodeName:function nodeName(elem,name){return elem.nodeName&&elem.nodeName.toLowerCase()===name.toLowerCase();},each:function each(obj,callback){var length,i=0;if(isArrayLike(obj)){length=obj.length;for(;i<length;i++){if(callback.call(obj[i],i,obj[i])===false){break;}}}else{for(i in obj){if(callback.call(obj[i],i,obj[i])===false){break;}}}return obj;},// Support: Android <=4.0 only
	trim:function trim(text){return text==null?"":(text+"").replace(rtrim,"");},// results is for internal usage only
	makeArray:function makeArray(arr,results){var ret=results||[];if(arr!=null){if(isArrayLike(Object(arr))){jQuery.merge(ret,typeof arr==="string"?[arr]:arr);}else{push.call(ret,arr);}}return ret;},inArray:function inArray(elem,arr,i){return arr==null?-1:indexOf.call(arr,elem,i);},// Support: Android <=4.0 only, PhantomJS 1 only
	// push.apply(_, arraylike) throws on ancient WebKit
	merge:function merge(first,second){var len=+second.length,j=0,i=first.length;for(;j<len;j++){first[i++]=second[j];}first.length=i;return first;},grep:function grep(elems,callback,invert){var callbackInverse,matches=[],i=0,length=elems.length,callbackExpect=!invert;// Go through the array, only saving the items
	// that pass the validator function
	for(;i<length;i++){callbackInverse=!callback(elems[i],i);if(callbackInverse!==callbackExpect){matches.push(elems[i]);}}return matches;},// arg is for internal usage only
	map:function map(elems,callback,arg){var length,value,i=0,ret=[];// Go through the array, translating each of the items to their new values
	if(isArrayLike(elems)){length=elems.length;for(;i<length;i++){value=callback(elems[i],i,arg);if(value!=null){ret.push(value);}}// Go through every key on the object,
	}else{for(i in elems){value=callback(elems[i],i,arg);if(value!=null){ret.push(value);}}}// Flatten any nested arrays
	return concat.apply([],ret);},// A global GUID counter for objects
	guid:1,// Bind a function to a context, optionally partially applying any
	// arguments.
	proxy:function proxy(fn,context){var tmp,args,proxy;if(typeof context==="string"){tmp=fn[context];context=fn;fn=tmp;}// Quick check to determine if target is callable, in the spec
	// this throws a TypeError, but we will just return undefined.
	if(!jQuery.isFunction(fn)){return undefined;}// Simulated bind
	args=_slice.call(arguments,2);proxy=function proxy(){return fn.apply(context||this,args.concat(_slice.call(arguments)));};// Set the guid of unique handler to the same of original handler, so it can be removed
	proxy.guid=fn.guid=fn.guid||jQuery.guid++;return proxy;},now:Date.now,// jQuery.support is not used in Core but other projects attach their
	// properties to it so it needs to exist.
	support:support});// JSHint would error on this code due to the Symbol not being defined in ES5.
	// Defining this global in .jshintrc would create a danger of using the global
	// unguarded in another place, it seems safer to just disable JSHint for these
	// three lines.
	/* jshint ignore: start */if(typeof Symbol==="function"){jQuery.fn[Symbol.iterator]=arr[Symbol.iterator];}/* jshint ignore: end */// Populate the class2type map
	jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(i,name){class2type["[object "+name+"]"]=name.toLowerCase();});function isArrayLike(obj){// Support: real iOS 8.2 only (not reproducible in simulator)
	// `in` check used to prevent JIT error (gh-2145)
	// hasOwn isn't used here due to false negatives
	// regarding Nodelist length in IE
	var length=!!obj&&"length"in obj&&obj.length,type=jQuery.type(obj);if(type==="function"||jQuery.isWindow(obj)){return false;}return type==="array"||length===0||typeof length==="number"&&length>0&&length-1 in obj;}var Sizzle=/*!
	 * Sizzle CSS Selector Engine v2.3.0
	 * https://sizzlejs.com/
	 *
	 * Copyright jQuery Foundation and other contributors
	 * Released under the MIT license
	 * http://jquery.org/license
	 *
	 * Date: 2016-01-04
	 */function(window){var i,support,Expr,getText,isXML,tokenize,compile,select,outermostContext,sortInput,hasDuplicate,// Local document vars
	setDocument,document,docElem,documentIsHTML,rbuggyQSA,rbuggyMatches,matches,contains,// Instance-specific data
	expando="sizzle"+1*new Date(),preferredDoc=window.document,dirruns=0,done=0,classCache=createCache(),tokenCache=createCache(),compilerCache=createCache(),sortOrder=function sortOrder(a,b){if(a===b){hasDuplicate=true;}return 0;},// Instance methods
	hasOwn={}.hasOwnProperty,arr=[],pop=arr.pop,push_native=arr.push,push=arr.push,slice=arr.slice,// Use a stripped-down indexOf as it's faster than native
	// https://jsperf.com/thor-indexof-vs-for/5
	indexOf=function indexOf(list,elem){var i=0,len=list.length;for(;i<len;i++){if(list[i]===elem){return i;}}return-1;},booleans="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",// Regular expressions
	// http://www.w3.org/TR/css3-selectors/#whitespace
	whitespace="[\\x20\\t\\r\\n\\f]",// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
	identifier="(?:\\\\.|[\\w-]|[^\0-\\xa0])+",// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
	attributes="\\["+whitespace+"*("+identifier+")(?:"+whitespace+// Operator (capture 2)
	"*([*^$|!~]?=)"+whitespace+// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
	"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+identifier+"))|)"+whitespace+"*\\]",pseudos=":("+identifier+")(?:\\(("+// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
	// 1. quoted (capture 3; capture 4 or capture 5)
	"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|"+// 2. simple (capture 6)
	"((?:\\\\.|[^\\\\()[\\]]|"+attributes+")*)|"+// 3. anything else (capture 2)
	".*"+")\\)|)",// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
	rwhitespace=new RegExp(whitespace+"+","g"),rtrim=new RegExp("^"+whitespace+"+|((?:^|[^\\\\])(?:\\\\.)*)"+whitespace+"+$","g"),rcomma=new RegExp("^"+whitespace+"*,"+whitespace+"*"),rcombinators=new RegExp("^"+whitespace+"*([>+~]|"+whitespace+")"+whitespace+"*"),rattributeQuotes=new RegExp("="+whitespace+"*([^\\]'\"]*?)"+whitespace+"*\\]","g"),rpseudo=new RegExp(pseudos),ridentifier=new RegExp("^"+identifier+"$"),matchExpr={"ID":new RegExp("^#("+identifier+")"),"CLASS":new RegExp("^\\.("+identifier+")"),"TAG":new RegExp("^("+identifier+"|[*])"),"ATTR":new RegExp("^"+attributes),"PSEUDO":new RegExp("^"+pseudos),"CHILD":new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+whitespace+"*(even|odd|(([+-]|)(\\d*)n|)"+whitespace+"*(?:([+-]|)"+whitespace+"*(\\d+)|))"+whitespace+"*\\)|)","i"),"bool":new RegExp("^(?:"+booleans+")$","i"),// For use in libraries implementing .is()
	// We use this for POS matching in `select`
	"needsContext":new RegExp("^"+whitespace+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+whitespace+"*((?:-\\d)?\\d*)"+whitespace+"*\\)|)(?=[^-]|$)","i")},rinputs=/^(?:input|select|textarea|button)$/i,rheader=/^h\d$/i,rnative=/^[^{]+\{\s*\[native \w/,// Easily-parseable/retrievable ID or TAG or CLASS selectors
	rquickExpr=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,rsibling=/[+~]/,// CSS escapes
	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
	runescape=new RegExp("\\\\([\\da-f]{1,6}"+whitespace+"?|("+whitespace+")|.)","ig"),funescape=function funescape(_,escaped,escapedWhitespace){var high="0x"+escaped-0x10000;// NaN means non-codepoint
	// Support: Firefox<24
	// Workaround erroneous numeric interpretation of +"0x"
	return high!==high||escapedWhitespace?escaped:high<0?// BMP codepoint
	String.fromCharCode(high+0x10000):// Supplemental Plane codepoint (surrogate pair)
	String.fromCharCode(high>>10|0xD800,high&0x3FF|0xDC00);},// CSS string/identifier serialization
	// https://drafts.csswg.org/cssom/#common-serializing-idioms
	rcssescape=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g,fcssescape=function fcssescape(ch,asCodePoint){if(asCodePoint){// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
	if(ch==="\0"){return"�";}// Control characters and (dependent upon position) numbers get escaped as code points
	return ch.slice(0,-1)+"\\"+ch.charCodeAt(ch.length-1).toString(16)+" ";}// Other potentially-special ASCII characters get backslash-escaped
	return"\\"+ch;},// Used for iframes
	// See setDocument()
	// Removing the function wrapper causes a "Permission Denied"
	// error in IE
	unloadHandler=function unloadHandler(){setDocument();},disabledAncestor=addCombinator(function(elem){return elem.disabled===true;},{dir:"parentNode",next:"legend"});// Optimize for push.apply( _, NodeList )
	try{push.apply(arr=slice.call(preferredDoc.childNodes),preferredDoc.childNodes);// Support: Android<4.0
	// Detect silently failing push.apply
	arr[preferredDoc.childNodes.length].nodeType;}catch(e){push={apply:arr.length?// Leverage slice if possible
	function(target,els){push_native.apply(target,slice.call(els));}:// Support: IE<9
	// Otherwise append directly
	function(target,els){var j=target.length,i=0;// Can't trust NodeList.length
	while(target[j++]=els[i++]){}target.length=j-1;}};}function Sizzle(selector,context,results,seed){var m,i,elem,nid,match,groups,newSelector,newContext=context&&context.ownerDocument,// nodeType defaults to 9, since context defaults to document
	nodeType=context?context.nodeType:9;results=results||[];// Return early from calls with invalid selector or context
	if(typeof selector!=="string"||!selector||nodeType!==1&&nodeType!==9&&nodeType!==11){return results;}// Try to shortcut find operations (as opposed to filters) in HTML documents
	if(!seed){if((context?context.ownerDocument||context:preferredDoc)!==document){setDocument(context);}context=context||document;if(documentIsHTML){// If the selector is sufficiently simple, try using a "get*By*" DOM method
	// (excepting DocumentFragment context, where the methods don't exist)
	if(nodeType!==11&&(match=rquickExpr.exec(selector))){// ID selector
	if(m=match[1]){// Document context
	if(nodeType===9){if(elem=context.getElementById(m)){// Support: IE, Opera, Webkit
	// TODO: identify versions
	// getElementById can match elements by name instead of ID
	if(elem.id===m){results.push(elem);return results;}}else{return results;}// Element context
	}else{// Support: IE, Opera, Webkit
	// TODO: identify versions
	// getElementById can match elements by name instead of ID
	if(newContext&&(elem=newContext.getElementById(m))&&contains(context,elem)&&elem.id===m){results.push(elem);return results;}}// Type selector
	}else if(match[2]){push.apply(results,context.getElementsByTagName(selector));return results;// Class selector
	}else if((m=match[3])&&support.getElementsByClassName&&context.getElementsByClassName){push.apply(results,context.getElementsByClassName(m));return results;}}// Take advantage of querySelectorAll
	if(support.qsa&&!compilerCache[selector+" "]&&(!rbuggyQSA||!rbuggyQSA.test(selector))){if(nodeType!==1){newContext=context;newSelector=selector;// qSA looks outside Element context, which is not what we want
	// Thanks to Andrew Dupont for this workaround technique
	// Support: IE <=8
	// Exclude object elements
	}else if(context.nodeName.toLowerCase()!=="object"){// Capture the context ID, setting it first if necessary
	if(nid=context.getAttribute("id")){nid=nid.replace(rcssescape,fcssescape);}else{context.setAttribute("id",nid=expando);}// Prefix every selector in the list
	groups=tokenize(selector);i=groups.length;while(i--){groups[i]="#"+nid+" "+toSelector(groups[i]);}newSelector=groups.join(",");// Expand context for sibling selectors
	newContext=rsibling.test(selector)&&testContext(context.parentNode)||context;}if(newSelector){try{push.apply(results,newContext.querySelectorAll(newSelector));return results;}catch(qsaError){}finally{if(nid===expando){context.removeAttribute("id");}}}}}}// All others
	return select(selector.replace(rtrim,"$1"),context,results,seed);}/**
	 * Create key-value caches of limited size
	 * @returns {function(string, object)} Returns the Object data after storing it on itself with
	 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
	 *	deleting the oldest entry
	 */function createCache(){var keys=[];function cache(key,value){// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
	if(keys.push(key+" ")>Expr.cacheLength){// Only keep the most recent entries
	delete cache[keys.shift()];}return cache[key+" "]=value;}return cache;}/**
	 * Mark a function for special use by Sizzle
	 * @param {Function} fn The function to mark
	 */function markFunction(fn){fn[expando]=true;return fn;}/**
	 * Support testing using an element
	 * @param {Function} fn Passed the created element and returns a boolean result
	 */function assert(fn){var el=document.createElement("fieldset");try{return!!fn(el);}catch(e){return false;}finally{// Remove from its parent by default
	if(el.parentNode){el.parentNode.removeChild(el);}// release memory in IE
	el=null;}}/**
	 * Adds the same handler for all of the specified attrs
	 * @param {String} attrs Pipe-separated list of attributes
	 * @param {Function} handler The method that will be applied
	 */function addHandle(attrs,handler){var arr=attrs.split("|"),i=arr.length;while(i--){Expr.attrHandle[arr[i]]=handler;}}/**
	 * Checks document order of two siblings
	 * @param {Element} a
	 * @param {Element} b
	 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
	 */function siblingCheck(a,b){var cur=b&&a,diff=cur&&a.nodeType===1&&b.nodeType===1&&a.sourceIndex-b.sourceIndex;// Use IE sourceIndex if available on both nodes
	if(diff){return diff;}// Check if b follows a
	if(cur){while(cur=cur.nextSibling){if(cur===b){return-1;}}}return a?1:-1;}/**
	 * Returns a function to use in pseudos for input types
	 * @param {String} type
	 */function createInputPseudo(type){return function(elem){var name=elem.nodeName.toLowerCase();return name==="input"&&elem.type===type;};}/**
	 * Returns a function to use in pseudos for buttons
	 * @param {String} type
	 */function createButtonPseudo(type){return function(elem){var name=elem.nodeName.toLowerCase();return(name==="input"||name==="button")&&elem.type===type;};}/**
	 * Returns a function to use in pseudos for :enabled/:disabled
	 * @param {Boolean} disabled true for :disabled; false for :enabled
	 */function createDisabledPseudo(disabled){// Known :disabled false positives:
	// IE: *[disabled]:not(button, input, select, textarea, optgroup, option, menuitem, fieldset)
	// not IE: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
	return function(elem){// Check form elements and option elements for explicit disabling
	return"label"in elem&&elem.disabled===disabled||"form"in elem&&elem.disabled===disabled||// Check non-disabled form elements for fieldset[disabled] ancestors
	"form"in elem&&elem.disabled===false&&(// Support: IE6-11+
	// Ancestry is covered for us
	elem.isDisabled===disabled||// Otherwise, assume any non-<option> under fieldset[disabled] is disabled
	/* jshint -W018 */elem.isDisabled!==!disabled&&("label"in elem||!disabledAncestor(elem))!==disabled);};}/**
	 * Returns a function to use in pseudos for positionals
	 * @param {Function} fn
	 */function createPositionalPseudo(fn){return markFunction(function(argument){argument=+argument;return markFunction(function(seed,matches){var j,matchIndexes=fn([],seed.length,argument),i=matchIndexes.length;// Match elements found at the specified indexes
	while(i--){if(seed[j=matchIndexes[i]]){seed[j]=!(matches[j]=seed[j]);}}});});}/**
	 * Checks a node for validity as a Sizzle context
	 * @param {Element|Object=} context
	 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
	 */function testContext(context){return context&&typeof context.getElementsByTagName!=="undefined"&&context;}// Expose support vars for convenience
	support=Sizzle.support={};/**
	 * Detects XML nodes
	 * @param {Element|Object} elem An element or a document
	 * @returns {Boolean} True iff elem is a non-HTML XML node
	 */isXML=Sizzle.isXML=function(elem){// documentElement is verified for cases where it doesn't yet exist
	// (such as loading iframes in IE - #4833)
	var documentElement=elem&&(elem.ownerDocument||elem).documentElement;return documentElement?documentElement.nodeName!=="HTML":false;};/**
	 * Sets document-related variables once based on the current document
	 * @param {Element|Object} [doc] An element or document object to use to set the document
	 * @returns {Object} Returns the current document
	 */setDocument=Sizzle.setDocument=function(node){var hasCompare,subWindow,doc=node?node.ownerDocument||node:preferredDoc;// Return early if doc is invalid or already selected
	if(doc===document||doc.nodeType!==9||!doc.documentElement){return document;}// Update global variables
	document=doc;docElem=document.documentElement;documentIsHTML=!isXML(document);// Support: IE 9-11, Edge
	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
	if(preferredDoc!==document&&(subWindow=document.defaultView)&&subWindow.top!==subWindow){// Support: IE 11, Edge
	if(subWindow.addEventListener){subWindow.addEventListener("unload",unloadHandler,false);// Support: IE 9 - 10 only
	}else if(subWindow.attachEvent){subWindow.attachEvent("onunload",unloadHandler);}}/* Attributes
		---------------------------------------------------------------------- */// Support: IE<8
	// Verify that getAttribute really returns attributes and not properties
	// (excepting IE8 booleans)
	support.attributes=assert(function(el){el.className="i";return!el.getAttribute("className");});/* getElement(s)By*
		---------------------------------------------------------------------- */// Check if getElementsByTagName("*") returns only elements
	support.getElementsByTagName=assert(function(el){el.appendChild(document.createComment(""));return!el.getElementsByTagName("*").length;});// Support: IE<9
	support.getElementsByClassName=rnative.test(document.getElementsByClassName);// Support: IE<10
	// Check if getElementById returns elements by name
	// The broken getElementById methods don't pick up programmatically-set names,
	// so use a roundabout getElementsByName test
	support.getById=assert(function(el){docElem.appendChild(el).id=expando;return!document.getElementsByName||!document.getElementsByName(expando).length;});// ID find and filter
	if(support.getById){Expr.find["ID"]=function(id,context){if(typeof context.getElementById!=="undefined"&&documentIsHTML){var m=context.getElementById(id);return m?[m]:[];}};Expr.filter["ID"]=function(id){var attrId=id.replace(runescape,funescape);return function(elem){return elem.getAttribute("id")===attrId;};};}else{// Support: IE6/7
	// getElementById is not reliable as a find shortcut
	delete Expr.find["ID"];Expr.filter["ID"]=function(id){var attrId=id.replace(runescape,funescape);return function(elem){var node=typeof elem.getAttributeNode!=="undefined"&&elem.getAttributeNode("id");return node&&node.value===attrId;};};}// Tag
	Expr.find["TAG"]=support.getElementsByTagName?function(tag,context){if(typeof context.getElementsByTagName!=="undefined"){return context.getElementsByTagName(tag);// DocumentFragment nodes don't have gEBTN
	}else if(support.qsa){return context.querySelectorAll(tag);}}:function(tag,context){var elem,tmp=[],i=0,// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
	results=context.getElementsByTagName(tag);// Filter out possible comments
	if(tag==="*"){while(elem=results[i++]){if(elem.nodeType===1){tmp.push(elem);}}return tmp;}return results;};// Class
	Expr.find["CLASS"]=support.getElementsByClassName&&function(className,context){if(typeof context.getElementsByClassName!=="undefined"&&documentIsHTML){return context.getElementsByClassName(className);}};/* QSA/matchesSelector
		---------------------------------------------------------------------- */// QSA and matchesSelector support
	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
	rbuggyMatches=[];// qSa(:focus) reports false when true (Chrome 21)
	// We allow this because of a bug in IE8/9 that throws an error
	// whenever `document.activeElement` is accessed on an iframe
	// So, we allow :focus to pass through QSA all the time to avoid the IE error
	// See https://bugs.jquery.com/ticket/13378
	rbuggyQSA=[];if(support.qsa=rnative.test(document.querySelectorAll)){// Build QSA regex
	// Regex strategy adopted from Diego Perini
	assert(function(el){// Select is set to empty string on purpose
	// This is to test IE's treatment of not explicitly
	// setting a boolean content attribute,
	// since its presence should be enough
	// https://bugs.jquery.com/ticket/12359
	docElem.appendChild(el).innerHTML="<a id='"+expando+"'></a>"+"<select id='"+expando+"-\r\\' msallowcapture=''>"+"<option selected=''></option></select>";// Support: IE8, Opera 11-12.16
	// Nothing should be selected when empty strings follow ^= or $= or *=
	// The test attribute must be unknown in Opera but "safe" for WinRT
	// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
	if(el.querySelectorAll("[msallowcapture^='']").length){rbuggyQSA.push("[*^$]="+whitespace+"*(?:''|\"\")");}// Support: IE8
	// Boolean attributes and "value" are not treated correctly
	if(!el.querySelectorAll("[selected]").length){rbuggyQSA.push("\\["+whitespace+"*(?:value|"+booleans+")");}// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
	if(!el.querySelectorAll("[id~="+expando+"-]").length){rbuggyQSA.push("~=");}// Webkit/Opera - :checked should return selected option elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	// IE8 throws error here and will not see later tests
	if(!el.querySelectorAll(":checked").length){rbuggyQSA.push(":checked");}// Support: Safari 8+, iOS 8+
	// https://bugs.webkit.org/show_bug.cgi?id=136851
	// In-page `selector#id sibling-combinator selector` fails
	if(!el.querySelectorAll("a#"+expando+"+*").length){rbuggyQSA.push(".#.+[+~]");}});assert(function(el){el.innerHTML="<a href='' disabled='disabled'></a>"+"<select disabled='disabled'><option/></select>";// Support: Windows 8 Native Apps
	// The type and name attributes are restricted during .innerHTML assignment
	var input=document.createElement("input");input.setAttribute("type","hidden");el.appendChild(input).setAttribute("name","D");// Support: IE8
	// Enforce case-sensitivity of name attribute
	if(el.querySelectorAll("[name=d]").length){rbuggyQSA.push("name"+whitespace+"*[*^$|!~]?=");}// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
	// IE8 throws error here and will not see later tests
	if(el.querySelectorAll(":enabled").length!==2){rbuggyQSA.push(":enabled",":disabled");}// Support: IE9-11+
	// IE's :disabled selector does not pick up the children of disabled fieldsets
	docElem.appendChild(el).disabled=true;if(el.querySelectorAll(":disabled").length!==2){rbuggyQSA.push(":enabled",":disabled");}// Opera 10-11 does not throw on post-comma invalid pseudos
	el.querySelectorAll("*,:x");rbuggyQSA.push(",.*:");});}if(support.matchesSelector=rnative.test(matches=docElem.matches||docElem.webkitMatchesSelector||docElem.mozMatchesSelector||docElem.oMatchesSelector||docElem.msMatchesSelector)){assert(function(el){// Check to see if it's possible to do matchesSelector
	// on a disconnected node (IE 9)
	support.disconnectedMatch=matches.call(el,"*");// This should fail with an exception
	// Gecko does not error, returns false instead
	matches.call(el,"[s!='']:x");rbuggyMatches.push("!=",pseudos);});}rbuggyQSA=rbuggyQSA.length&&new RegExp(rbuggyQSA.join("|"));rbuggyMatches=rbuggyMatches.length&&new RegExp(rbuggyMatches.join("|"));/* Contains
		---------------------------------------------------------------------- */hasCompare=rnative.test(docElem.compareDocumentPosition);// Element contains another
	// Purposefully self-exclusive
	// As in, an element does not contain itself
	contains=hasCompare||rnative.test(docElem.contains)?function(a,b){var adown=a.nodeType===9?a.documentElement:a,bup=b&&b.parentNode;return a===bup||!!(bup&&bup.nodeType===1&&(adown.contains?adown.contains(bup):a.compareDocumentPosition&&a.compareDocumentPosition(bup)&16));}:function(a,b){if(b){while(b=b.parentNode){if(b===a){return true;}}}return false;};/* Sorting
		---------------------------------------------------------------------- */// Document order sorting
	sortOrder=hasCompare?function(a,b){// Flag for duplicate removal
	if(a===b){hasDuplicate=true;return 0;}// Sort on method existence if only one input has compareDocumentPosition
	var compare=!a.compareDocumentPosition-!b.compareDocumentPosition;if(compare){return compare;}// Calculate position if both inputs belong to the same document
	compare=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):// Otherwise we know they are disconnected
	1;// Disconnected nodes
	if(compare&1||!support.sortDetached&&b.compareDocumentPosition(a)===compare){// Choose the first element that is related to our preferred document
	if(a===document||a.ownerDocument===preferredDoc&&contains(preferredDoc,a)){return-1;}if(b===document||b.ownerDocument===preferredDoc&&contains(preferredDoc,b)){return 1;}// Maintain original order
	return sortInput?indexOf(sortInput,a)-indexOf(sortInput,b):0;}return compare&4?-1:1;}:function(a,b){// Exit early if the nodes are identical
	if(a===b){hasDuplicate=true;return 0;}var cur,i=0,aup=a.parentNode,bup=b.parentNode,ap=[a],bp=[b];// Parentless nodes are either documents or disconnected
	if(!aup||!bup){return a===document?-1:b===document?1:aup?-1:bup?1:sortInput?indexOf(sortInput,a)-indexOf(sortInput,b):0;// If the nodes are siblings, we can do a quick check
	}else if(aup===bup){return siblingCheck(a,b);}// Otherwise we need full lists of their ancestors for comparison
	cur=a;while(cur=cur.parentNode){ap.unshift(cur);}cur=b;while(cur=cur.parentNode){bp.unshift(cur);}// Walk down the tree looking for a discrepancy
	while(ap[i]===bp[i]){i++;}return i?// Do a sibling check if the nodes have a common ancestor
	siblingCheck(ap[i],bp[i]):// Otherwise nodes in our document sort first
	ap[i]===preferredDoc?-1:bp[i]===preferredDoc?1:0;};return document;};Sizzle.matches=function(expr,elements){return Sizzle(expr,null,null,elements);};Sizzle.matchesSelector=function(elem,expr){// Set document vars if needed
	if((elem.ownerDocument||elem)!==document){setDocument(elem);}// Make sure that attribute selectors are quoted
	expr=expr.replace(rattributeQuotes,"='$1']");if(support.matchesSelector&&documentIsHTML&&!compilerCache[expr+" "]&&(!rbuggyMatches||!rbuggyMatches.test(expr))&&(!rbuggyQSA||!rbuggyQSA.test(expr))){try{var ret=matches.call(elem,expr);// IE 9's matchesSelector returns false on disconnected nodes
	if(ret||support.disconnectedMatch||// As well, disconnected nodes are said to be in a document
	// fragment in IE 9
	elem.document&&elem.document.nodeType!==11){return ret;}}catch(e){}}return Sizzle(expr,document,null,[elem]).length>0;};Sizzle.contains=function(context,elem){// Set document vars if needed
	if((context.ownerDocument||context)!==document){setDocument(context);}return contains(context,elem);};Sizzle.attr=function(elem,name){// Set document vars if needed
	if((elem.ownerDocument||elem)!==document){setDocument(elem);}var fn=Expr.attrHandle[name.toLowerCase()],// Don't get fooled by Object.prototype properties (jQuery #13807)
	val=fn&&hasOwn.call(Expr.attrHandle,name.toLowerCase())?fn(elem,name,!documentIsHTML):undefined;return val!==undefined?val:support.attributes||!documentIsHTML?elem.getAttribute(name):(val=elem.getAttributeNode(name))&&val.specified?val.value:null;};Sizzle.escape=function(sel){return(sel+"").replace(rcssescape,fcssescape);};Sizzle.error=function(msg){throw new Error("Syntax error, unrecognized expression: "+msg);};/**
	 * Document sorting and removing duplicates
	 * @param {ArrayLike} results
	 */Sizzle.uniqueSort=function(results){var elem,duplicates=[],j=0,i=0;// Unless we *know* we can detect duplicates, assume their presence
	hasDuplicate=!support.detectDuplicates;sortInput=!support.sortStable&&results.slice(0);results.sort(sortOrder);if(hasDuplicate){while(elem=results[i++]){if(elem===results[i]){j=duplicates.push(i);}}while(j--){results.splice(duplicates[j],1);}}// Clear input after sorting to release objects
	// See https://github.com/jquery/sizzle/pull/225
	sortInput=null;return results;};/**
	 * Utility function for retrieving the text value of an array of DOM nodes
	 * @param {Array|Element} elem
	 */getText=Sizzle.getText=function(elem){var node,ret="",i=0,nodeType=elem.nodeType;if(!nodeType){// If no nodeType, this is expected to be an array
	while(node=elem[i++]){// Do not traverse comment nodes
	ret+=getText(node);}}else if(nodeType===1||nodeType===9||nodeType===11){// Use textContent for elements
	// innerText usage removed for consistency of new lines (jQuery #11153)
	if(typeof elem.textContent==="string"){return elem.textContent;}else{// Traverse its children
	for(elem=elem.firstChild;elem;elem=elem.nextSibling){ret+=getText(elem);}}}else if(nodeType===3||nodeType===4){return elem.nodeValue;}// Do not include comment or processing instruction nodes
	return ret;};Expr=Sizzle.selectors={// Can be adjusted by the user
	cacheLength:50,createPseudo:markFunction,match:matchExpr,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:true}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:true},"~":{dir:"previousSibling"}},preFilter:{"ATTR":function ATTR(match){match[1]=match[1].replace(runescape,funescape);// Move the given value to match[3] whether quoted or unquoted
	match[3]=(match[3]||match[4]||match[5]||"").replace(runescape,funescape);if(match[2]==="~="){match[3]=" "+match[3]+" ";}return match.slice(0,4);},"CHILD":function CHILD(match){/* matches from matchExpr["CHILD"]
					1 type (only|nth|...)
					2 what (child|of-type)
					3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
					4 xn-component of xn+y argument ([+-]?\d*n|)
					5 sign of xn-component
					6 x of xn-component
					7 sign of y-component
					8 y of y-component
				*/match[1]=match[1].toLowerCase();if(match[1].slice(0,3)==="nth"){// nth-* requires argument
	if(!match[3]){Sizzle.error(match[0]);}// numeric x and y parameters for Expr.filter.CHILD
	// remember that false/true cast respectively to 0/1
	match[4]=+(match[4]?match[5]+(match[6]||1):2*(match[3]==="even"||match[3]==="odd"));match[5]=+(match[7]+match[8]||match[3]==="odd");// other types prohibit arguments
	}else if(match[3]){Sizzle.error(match[0]);}return match;},"PSEUDO":function PSEUDO(match){var excess,unquoted=!match[6]&&match[2];if(matchExpr["CHILD"].test(match[0])){return null;}// Accept quoted arguments as-is
	if(match[3]){match[2]=match[4]||match[5]||"";// Strip excess characters from unquoted arguments
	}else if(unquoted&&rpseudo.test(unquoted)&&(// Get excess from tokenize (recursively)
	excess=tokenize(unquoted,true))&&(// advance to the next closing parenthesis
	excess=unquoted.indexOf(")",unquoted.length-excess)-unquoted.length)){// excess is a negative index
	match[0]=match[0].slice(0,excess);match[2]=unquoted.slice(0,excess);}// Return only captures needed by the pseudo filter method (type and argument)
	return match.slice(0,3);}},filter:{"TAG":function TAG(nodeNameSelector){var nodeName=nodeNameSelector.replace(runescape,funescape).toLowerCase();return nodeNameSelector==="*"?function(){return true;}:function(elem){return elem.nodeName&&elem.nodeName.toLowerCase()===nodeName;};},"CLASS":function CLASS(className){var pattern=classCache[className+" "];return pattern||(pattern=new RegExp("(^|"+whitespace+")"+className+"("+whitespace+"|$)"))&&classCache(className,function(elem){return pattern.test(typeof elem.className==="string"&&elem.className||typeof elem.getAttribute!=="undefined"&&elem.getAttribute("class")||"");});},"ATTR":function ATTR(name,operator,check){return function(elem){var result=Sizzle.attr(elem,name);if(result==null){return operator==="!=";}if(!operator){return true;}result+="";return operator==="="?result===check:operator==="!="?result!==check:operator==="^="?check&&result.indexOf(check)===0:operator==="*="?check&&result.indexOf(check)>-1:operator==="$="?check&&result.slice(-check.length)===check:operator==="~="?(" "+result.replace(rwhitespace," ")+" ").indexOf(check)>-1:operator==="|="?result===check||result.slice(0,check.length+1)===check+"-":false;};},"CHILD":function CHILD(type,what,argument,first,last){var simple=type.slice(0,3)!=="nth",forward=type.slice(-4)!=="last",ofType=what==="of-type";return first===1&&last===0?// Shortcut for :nth-*(n)
	function(elem){return!!elem.parentNode;}:function(elem,context,xml){var cache,uniqueCache,outerCache,node,nodeIndex,start,dir=simple!==forward?"nextSibling":"previousSibling",parent=elem.parentNode,name=ofType&&elem.nodeName.toLowerCase(),useCache=!xml&&!ofType,diff=false;if(parent){// :(first|last|only)-(child|of-type)
	if(simple){while(dir){node=elem;while(node=node[dir]){if(ofType?node.nodeName.toLowerCase()===name:node.nodeType===1){return false;}}// Reverse direction for :only-* (if we haven't yet done so)
	start=dir=type==="only"&&!start&&"nextSibling";}return true;}start=[forward?parent.firstChild:parent.lastChild];// non-xml :nth-child(...) stores cache data on `parent`
	if(forward&&useCache){// Seek `elem` from a previously-cached index
	// ...in a gzip-friendly way
	node=parent;outerCache=node[expando]||(node[expando]={});// Support: IE <9 only
	// Defend against cloned attroperties (jQuery gh-1709)
	uniqueCache=outerCache[node.uniqueID]||(outerCache[node.uniqueID]={});cache=uniqueCache[type]||[];nodeIndex=cache[0]===dirruns&&cache[1];diff=nodeIndex&&cache[2];node=nodeIndex&&parent.childNodes[nodeIndex];while(node=++nodeIndex&&node&&node[dir]||(// Fallback to seeking `elem` from the start
	diff=nodeIndex=0)||start.pop()){// When found, cache indexes on `parent` and break
	if(node.nodeType===1&&++diff&&node===elem){uniqueCache[type]=[dirruns,nodeIndex,diff];break;}}}else{// Use previously-cached element index if available
	if(useCache){// ...in a gzip-friendly way
	node=elem;outerCache=node[expando]||(node[expando]={});// Support: IE <9 only
	// Defend against cloned attroperties (jQuery gh-1709)
	uniqueCache=outerCache[node.uniqueID]||(outerCache[node.uniqueID]={});cache=uniqueCache[type]||[];nodeIndex=cache[0]===dirruns&&cache[1];diff=nodeIndex;}// xml :nth-child(...)
	// or :nth-last-child(...) or :nth(-last)?-of-type(...)
	if(diff===false){// Use the same loop as above to seek `elem` from the start
	while(node=++nodeIndex&&node&&node[dir]||(diff=nodeIndex=0)||start.pop()){if((ofType?node.nodeName.toLowerCase()===name:node.nodeType===1)&&++diff){// Cache the index of each encountered element
	if(useCache){outerCache=node[expando]||(node[expando]={});// Support: IE <9 only
	// Defend against cloned attroperties (jQuery gh-1709)
	uniqueCache=outerCache[node.uniqueID]||(outerCache[node.uniqueID]={});uniqueCache[type]=[dirruns,diff];}if(node===elem){break;}}}}}// Incorporate the offset, then check against cycle size
	diff-=last;return diff===first||diff%first===0&&diff/first>=0;}};},"PSEUDO":function PSEUDO(pseudo,argument){// pseudo-class names are case-insensitive
	// http://www.w3.org/TR/selectors/#pseudo-classes
	// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
	// Remember that setFilters inherits from pseudos
	var args,fn=Expr.pseudos[pseudo]||Expr.setFilters[pseudo.toLowerCase()]||Sizzle.error("unsupported pseudo: "+pseudo);// The user may use createPseudo to indicate that
	// arguments are needed to create the filter function
	// just as Sizzle does
	if(fn[expando]){return fn(argument);}// But maintain support for old signatures
	if(fn.length>1){args=[pseudo,pseudo,"",argument];return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase())?markFunction(function(seed,matches){var idx,matched=fn(seed,argument),i=matched.length;while(i--){idx=indexOf(seed,matched[i]);seed[idx]=!(matches[idx]=matched[i]);}}):function(elem){return fn(elem,0,args);};}return fn;}},pseudos:{// Potentially complex pseudos
	"not":markFunction(function(selector){// Trim the selector passed to compile
	// to avoid treating leading and trailing
	// spaces as combinators
	var input=[],results=[],matcher=compile(selector.replace(rtrim,"$1"));return matcher[expando]?markFunction(function(seed,matches,context,xml){var elem,unmatched=matcher(seed,null,xml,[]),i=seed.length;// Match elements unmatched by `matcher`
	while(i--){if(elem=unmatched[i]){seed[i]=!(matches[i]=elem);}}}):function(elem,context,xml){input[0]=elem;matcher(input,null,xml,results);// Don't keep the element (issue #299)
	input[0]=null;return!results.pop();};}),"has":markFunction(function(selector){return function(elem){return Sizzle(selector,elem).length>0;};}),"contains":markFunction(function(text){text=text.replace(runescape,funescape);return function(elem){return(elem.textContent||elem.innerText||getText(elem)).indexOf(text)>-1;};}),// "Whether an element is represented by a :lang() selector
	// is based solely on the element's language value
	// being equal to the identifier C,
	// or beginning with the identifier C immediately followed by "-".
	// The matching of C against the element's language value is performed case-insensitively.
	// The identifier C does not have to be a valid language name."
	// http://www.w3.org/TR/selectors/#lang-pseudo
	"lang":markFunction(function(lang){// lang value must be a valid identifier
	if(!ridentifier.test(lang||"")){Sizzle.error("unsupported lang: "+lang);}lang=lang.replace(runescape,funescape).toLowerCase();return function(elem){var elemLang;do{if(elemLang=documentIsHTML?elem.lang:elem.getAttribute("xml:lang")||elem.getAttribute("lang")){elemLang=elemLang.toLowerCase();return elemLang===lang||elemLang.indexOf(lang+"-")===0;}}while((elem=elem.parentNode)&&elem.nodeType===1);return false;};}),// Miscellaneous
	"target":function target(elem){var hash=window.location&&window.location.hash;return hash&&hash.slice(1)===elem.id;},"root":function root(elem){return elem===docElem;},"focus":function focus(elem){return elem===document.activeElement&&(!document.hasFocus||document.hasFocus())&&!!(elem.type||elem.href||~elem.tabIndex);},// Boolean properties
	"enabled":createDisabledPseudo(false),"disabled":createDisabledPseudo(true),"checked":function checked(elem){// In CSS3, :checked should return both checked and selected elements
	// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
	var nodeName=elem.nodeName.toLowerCase();return nodeName==="input"&&!!elem.checked||nodeName==="option"&&!!elem.selected;},"selected":function selected(elem){// Accessing this property makes selected-by-default
	// options in Safari work properly
	if(elem.parentNode){elem.parentNode.selectedIndex;}return elem.selected===true;},// Contents
	"empty":function empty(elem){// http://www.w3.org/TR/selectors/#empty-pseudo
	// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
	//   but not by others (comment: 8; processing instruction: 7; etc.)
	// nodeType < 6 works because attributes (2) do not appear as children
	for(elem=elem.firstChild;elem;elem=elem.nextSibling){if(elem.nodeType<6){return false;}}return true;},"parent":function parent(elem){return!Expr.pseudos["empty"](elem);},// Element/input types
	"header":function header(elem){return rheader.test(elem.nodeName);},"input":function input(elem){return rinputs.test(elem.nodeName);},"button":function button(elem){var name=elem.nodeName.toLowerCase();return name==="input"&&elem.type==="button"||name==="button";},"text":function text(elem){var attr;return elem.nodeName.toLowerCase()==="input"&&elem.type==="text"&&(// Support: IE<8
	// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
	(attr=elem.getAttribute("type"))==null||attr.toLowerCase()==="text");},// Position-in-collection
	"first":createPositionalPseudo(function(){return[0];}),"last":createPositionalPseudo(function(matchIndexes,length){return[length-1];}),"eq":createPositionalPseudo(function(matchIndexes,length,argument){return[argument<0?argument+length:argument];}),"even":createPositionalPseudo(function(matchIndexes,length){var i=0;for(;i<length;i+=2){matchIndexes.push(i);}return matchIndexes;}),"odd":createPositionalPseudo(function(matchIndexes,length){var i=1;for(;i<length;i+=2){matchIndexes.push(i);}return matchIndexes;}),"lt":createPositionalPseudo(function(matchIndexes,length,argument){var i=argument<0?argument+length:argument;for(;--i>=0;){matchIndexes.push(i);}return matchIndexes;}),"gt":createPositionalPseudo(function(matchIndexes,length,argument){var i=argument<0?argument+length:argument;for(;++i<length;){matchIndexes.push(i);}return matchIndexes;})}};Expr.pseudos["nth"]=Expr.pseudos["eq"];// Add button/input type pseudos
	for(i in{radio:true,checkbox:true,file:true,password:true,image:true}){Expr.pseudos[i]=createInputPseudo(i);}for(i in{submit:true,reset:true}){Expr.pseudos[i]=createButtonPseudo(i);}// Easy API for creating new setFilters
	function setFilters(){}setFilters.prototype=Expr.filters=Expr.pseudos;Expr.setFilters=new setFilters();tokenize=Sizzle.tokenize=function(selector,parseOnly){var matched,match,tokens,type,soFar,groups,preFilters,cached=tokenCache[selector+" "];if(cached){return parseOnly?0:cached.slice(0);}soFar=selector;groups=[];preFilters=Expr.preFilter;while(soFar){// Comma and first run
	if(!matched||(match=rcomma.exec(soFar))){if(match){// Don't consume trailing commas as valid
	soFar=soFar.slice(match[0].length)||soFar;}groups.push(tokens=[]);}matched=false;// Combinators
	if(match=rcombinators.exec(soFar)){matched=match.shift();tokens.push({value:matched,// Cast descendant combinators to space
	type:match[0].replace(rtrim," ")});soFar=soFar.slice(matched.length);}// Filters
	for(type in Expr.filter){if((match=matchExpr[type].exec(soFar))&&(!preFilters[type]||(match=preFilters[type](match)))){matched=match.shift();tokens.push({value:matched,type:type,matches:match});soFar=soFar.slice(matched.length);}}if(!matched){break;}}// Return the length of the invalid excess
	// if we're just parsing
	// Otherwise, throw an error or return tokens
	return parseOnly?soFar.length:soFar?Sizzle.error(selector):// Cache the tokens
	tokenCache(selector,groups).slice(0);};function toSelector(tokens){var i=0,len=tokens.length,selector="";for(;i<len;i++){selector+=tokens[i].value;}return selector;}function addCombinator(matcher,combinator,base){var dir=combinator.dir,skip=combinator.next,key=skip||dir,checkNonElements=base&&key==="parentNode",doneName=done++;return combinator.first?// Check against closest ancestor/preceding element
	function(elem,context,xml){while(elem=elem[dir]){if(elem.nodeType===1||checkNonElements){return matcher(elem,context,xml);}}}:// Check against all ancestor/preceding elements
	function(elem,context,xml){var oldCache,uniqueCache,outerCache,newCache=[dirruns,doneName];// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
	if(xml){while(elem=elem[dir]){if(elem.nodeType===1||checkNonElements){if(matcher(elem,context,xml)){return true;}}}}else{while(elem=elem[dir]){if(elem.nodeType===1||checkNonElements){outerCache=elem[expando]||(elem[expando]={});// Support: IE <9 only
	// Defend against cloned attroperties (jQuery gh-1709)
	uniqueCache=outerCache[elem.uniqueID]||(outerCache[elem.uniqueID]={});if(skip&&skip===elem.nodeName.toLowerCase()){elem=elem[dir]||elem;}else if((oldCache=uniqueCache[key])&&oldCache[0]===dirruns&&oldCache[1]===doneName){// Assign to newCache so results back-propagate to previous elements
	return newCache[2]=oldCache[2];}else{// Reuse newcache so results back-propagate to previous elements
	uniqueCache[key]=newCache;// A match means we're done; a fail means we have to keep checking
	if(newCache[2]=matcher(elem,context,xml)){return true;}}}}}};}function elementMatcher(matchers){return matchers.length>1?function(elem,context,xml){var i=matchers.length;while(i--){if(!matchers[i](elem,context,xml)){return false;}}return true;}:matchers[0];}function multipleContexts(selector,contexts,results){var i=0,len=contexts.length;for(;i<len;i++){Sizzle(selector,contexts[i],results);}return results;}function condense(unmatched,map,filter,context,xml){var elem,newUnmatched=[],i=0,len=unmatched.length,mapped=map!=null;for(;i<len;i++){if(elem=unmatched[i]){if(!filter||filter(elem,context,xml)){newUnmatched.push(elem);if(mapped){map.push(i);}}}}return newUnmatched;}function setMatcher(preFilter,selector,matcher,postFilter,postFinder,postSelector){if(postFilter&&!postFilter[expando]){postFilter=setMatcher(postFilter);}if(postFinder&&!postFinder[expando]){postFinder=setMatcher(postFinder,postSelector);}return markFunction(function(seed,results,context,xml){var temp,i,elem,preMap=[],postMap=[],preexisting=results.length,// Get initial elements from seed or context
	elems=seed||multipleContexts(selector||"*",context.nodeType?[context]:context,[]),// Prefilter to get matcher input, preserving a map for seed-results synchronization
	matcherIn=preFilter&&(seed||!selector)?condense(elems,preMap,preFilter,context,xml):elems,matcherOut=matcher?// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
	postFinder||(seed?preFilter:preexisting||postFilter)?// ...intermediate processing is necessary
	[]:// ...otherwise use results directly
	results:matcherIn;// Find primary matches
	if(matcher){matcher(matcherIn,matcherOut,context,xml);}// Apply postFilter
	if(postFilter){temp=condense(matcherOut,postMap);postFilter(temp,[],context,xml);// Un-match failing elements by moving them back to matcherIn
	i=temp.length;while(i--){if(elem=temp[i]){matcherOut[postMap[i]]=!(matcherIn[postMap[i]]=elem);}}}if(seed){if(postFinder||preFilter){if(postFinder){// Get the final matcherOut by condensing this intermediate into postFinder contexts
	temp=[];i=matcherOut.length;while(i--){if(elem=matcherOut[i]){// Restore matcherIn since elem is not yet a final match
	temp.push(matcherIn[i]=elem);}}postFinder(null,matcherOut=[],temp,xml);}// Move matched elements from seed to results to keep them synchronized
	i=matcherOut.length;while(i--){if((elem=matcherOut[i])&&(temp=postFinder?indexOf(seed,elem):preMap[i])>-1){seed[temp]=!(results[temp]=elem);}}}// Add elements to results, through postFinder if defined
	}else{matcherOut=condense(matcherOut===results?matcherOut.splice(preexisting,matcherOut.length):matcherOut);if(postFinder){postFinder(null,results,matcherOut,xml);}else{push.apply(results,matcherOut);}}});}function matcherFromTokens(tokens){var checkContext,matcher,j,len=tokens.length,leadingRelative=Expr.relative[tokens[0].type],implicitRelative=leadingRelative||Expr.relative[" "],i=leadingRelative?1:0,// The foundational matcher ensures that elements are reachable from top-level context(s)
	matchContext=addCombinator(function(elem){return elem===checkContext;},implicitRelative,true),matchAnyContext=addCombinator(function(elem){return indexOf(checkContext,elem)>-1;},implicitRelative,true),matchers=[function(elem,context,xml){var ret=!leadingRelative&&(xml||context!==outermostContext)||((checkContext=context).nodeType?matchContext(elem,context,xml):matchAnyContext(elem,context,xml));// Avoid hanging onto element (issue #299)
	checkContext=null;return ret;}];for(;i<len;i++){if(matcher=Expr.relative[tokens[i].type]){matchers=[addCombinator(elementMatcher(matchers),matcher)];}else{matcher=Expr.filter[tokens[i].type].apply(null,tokens[i].matches);// Return special upon seeing a positional matcher
	if(matcher[expando]){// Find the next relative operator (if any) for proper handling
	j=++i;for(;j<len;j++){if(Expr.relative[tokens[j].type]){break;}}return setMatcher(i>1&&elementMatcher(matchers),i>1&&toSelector(// If the preceding token was a descendant combinator, insert an implicit any-element `*`
	tokens.slice(0,i-1).concat({value:tokens[i-2].type===" "?"*":""})).replace(rtrim,"$1"),matcher,i<j&&matcherFromTokens(tokens.slice(i,j)),j<len&&matcherFromTokens(tokens=tokens.slice(j)),j<len&&toSelector(tokens));}matchers.push(matcher);}}return elementMatcher(matchers);}function matcherFromGroupMatchers(elementMatchers,setMatchers){var bySet=setMatchers.length>0,byElement=elementMatchers.length>0,superMatcher=function superMatcher(seed,context,xml,results,outermost){var elem,j,matcher,matchedCount=0,i="0",unmatched=seed&&[],setMatched=[],contextBackup=outermostContext,// We must always have either seed elements or outermost context
	elems=seed||byElement&&Expr.find["TAG"]("*",outermost),// Use integer dirruns iff this is the outermost matcher
	dirrunsUnique=dirruns+=contextBackup==null?1:Math.random()||0.1,len=elems.length;if(outermost){outermostContext=context===document||context||outermost;}// Add elements passing elementMatchers directly to results
	// Support: IE<9, Safari
	// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
	for(;i!==len&&(elem=elems[i])!=null;i++){if(byElement&&elem){j=0;if(!context&&elem.ownerDocument!==document){setDocument(elem);xml=!documentIsHTML;}while(matcher=elementMatchers[j++]){if(matcher(elem,context||document,xml)){results.push(elem);break;}}if(outermost){dirruns=dirrunsUnique;}}// Track unmatched elements for set filters
	if(bySet){// They will have gone through all possible matchers
	if(elem=!matcher&&elem){matchedCount--;}// Lengthen the array for every element, matched or not
	if(seed){unmatched.push(elem);}}}// `i` is now the count of elements visited above, and adding it to `matchedCount`
	// makes the latter nonnegative.
	matchedCount+=i;// Apply set filters to unmatched elements
	// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
	// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
	// no element matchers and no seed.
	// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
	// case, which will result in a "00" `matchedCount` that differs from `i` but is also
	// numerically zero.
	if(bySet&&i!==matchedCount){j=0;while(matcher=setMatchers[j++]){matcher(unmatched,setMatched,context,xml);}if(seed){// Reintegrate element matches to eliminate the need for sorting
	if(matchedCount>0){while(i--){if(!(unmatched[i]||setMatched[i])){setMatched[i]=pop.call(results);}}}// Discard index placeholder values to get only actual matches
	setMatched=condense(setMatched);}// Add matches to results
	push.apply(results,setMatched);// Seedless set matches succeeding multiple successful matchers stipulate sorting
	if(outermost&&!seed&&setMatched.length>0&&matchedCount+setMatchers.length>1){Sizzle.uniqueSort(results);}}// Override manipulation of globals by nested matchers
	if(outermost){dirruns=dirrunsUnique;outermostContext=contextBackup;}return unmatched;};return bySet?markFunction(superMatcher):superMatcher;}compile=Sizzle.compile=function(selector,match/* Internal Use Only */){var i,setMatchers=[],elementMatchers=[],cached=compilerCache[selector+" "];if(!cached){// Generate a function of recursive functions that can be used to check each element
	if(!match){match=tokenize(selector);}i=match.length;while(i--){cached=matcherFromTokens(match[i]);if(cached[expando]){setMatchers.push(cached);}else{elementMatchers.push(cached);}}// Cache the compiled function
	cached=compilerCache(selector,matcherFromGroupMatchers(elementMatchers,setMatchers));// Save selector and tokenization
	cached.selector=selector;}return cached;};/**
	 * A low-level selection function that works with Sizzle's compiled
	 *  selector functions
	 * @param {String|Function} selector A selector or a pre-compiled
	 *  selector function built with Sizzle.compile
	 * @param {Element} context
	 * @param {Array} [results]
	 * @param {Array} [seed] A set of elements to match against
	 */select=Sizzle.select=function(selector,context,results,seed){var i,tokens,token,type,find,compiled=typeof selector==="function"&&selector,match=!seed&&tokenize(selector=compiled.selector||selector);results=results||[];// Try to minimize operations if there is only one selector in the list and no seed
	// (the latter of which guarantees us context)
	if(match.length===1){// Reduce context if the leading compound selector is an ID
	tokens=match[0]=match[0].slice(0);if(tokens.length>2&&(token=tokens[0]).type==="ID"&&support.getById&&context.nodeType===9&&documentIsHTML&&Expr.relative[tokens[1].type]){context=(Expr.find["ID"](token.matches[0].replace(runescape,funescape),context)||[])[0];if(!context){return results;// Precompiled matchers will still verify ancestry, so step up a level
	}else if(compiled){context=context.parentNode;}selector=selector.slice(tokens.shift().value.length);}// Fetch a seed set for right-to-left matching
	i=matchExpr["needsContext"].test(selector)?0:tokens.length;while(i--){token=tokens[i];// Abort if we hit a combinator
	if(Expr.relative[type=token.type]){break;}if(find=Expr.find[type]){// Search, expanding context for leading sibling combinators
	if(seed=find(token.matches[0].replace(runescape,funescape),rsibling.test(tokens[0].type)&&testContext(context.parentNode)||context)){// If seed is empty or no tokens remain, we can return early
	tokens.splice(i,1);selector=seed.length&&toSelector(tokens);if(!selector){push.apply(results,seed);return results;}break;}}}}// Compile and execute a filtering function if one is not provided
	// Provide `match` to avoid retokenization if we modified the selector above
	(compiled||compile(selector,match))(seed,context,!documentIsHTML,results,!context||rsibling.test(selector)&&testContext(context.parentNode)||context);return results;};// One-time assignments
	// Sort stability
	support.sortStable=expando.split("").sort(sortOrder).join("")===expando;// Support: Chrome 14-35+
	// Always assume duplicates if they aren't passed to the comparison function
	support.detectDuplicates=!!hasDuplicate;// Initialize against the default document
	setDocument();// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
	// Detached nodes confoundingly follow *each other*
	support.sortDetached=assert(function(el){// Should return 1, but returns 4 (following)
	return el.compareDocumentPosition(document.createElement("fieldset"))&1;});// Support: IE<8
	// Prevent attribute/property "interpolation"
	// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
	if(!assert(function(el){el.innerHTML="<a href='#'></a>";return el.firstChild.getAttribute("href")==="#";})){addHandle("type|href|height|width",function(elem,name,isXML){if(!isXML){return elem.getAttribute(name,name.toLowerCase()==="type"?1:2);}});}// Support: IE<9
	// Use defaultValue in place of getAttribute("value")
	if(!support.attributes||!assert(function(el){el.innerHTML="<input/>";el.firstChild.setAttribute("value","");return el.firstChild.getAttribute("value")==="";})){addHandle("value",function(elem,name,isXML){if(!isXML&&elem.nodeName.toLowerCase()==="input"){return elem.defaultValue;}});}// Support: IE<9
	// Use getAttributeNode to fetch booleans when getAttribute lies
	if(!assert(function(el){return el.getAttribute("disabled")==null;})){addHandle(booleans,function(elem,name,isXML){var val;if(!isXML){return elem[name]===true?name.toLowerCase():(val=elem.getAttributeNode(name))&&val.specified?val.value:null;}});}return Sizzle;}(window);jQuery.find=Sizzle;jQuery.expr=Sizzle.selectors;// Deprecated
	jQuery.expr[":"]=jQuery.expr.pseudos;jQuery.uniqueSort=jQuery.unique=Sizzle.uniqueSort;jQuery.text=Sizzle.getText;jQuery.isXMLDoc=Sizzle.isXML;jQuery.contains=Sizzle.contains;jQuery.escapeSelector=Sizzle.escape;var dir=function dir(elem,_dir,until){var matched=[],truncate=until!==undefined;while((elem=elem[_dir])&&elem.nodeType!==9){if(elem.nodeType===1){if(truncate&&jQuery(elem).is(until)){break;}matched.push(elem);}}return matched;};var _siblings=function _siblings(n,elem){var matched=[];for(;n;n=n.nextSibling){if(n.nodeType===1&&n!==elem){matched.push(n);}}return matched;};var rneedsContext=jQuery.expr.match.needsContext;var rsingleTag=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;var risSimple=/^.[^:#\[\.,]*$/;// Implement the identical functionality for filter and not
	function winnow(elements,qualifier,not){if(jQuery.isFunction(qualifier)){return jQuery.grep(elements,function(elem,i){/* jshint -W018 */return!!qualifier.call(elem,i,elem)!==not;});}if(qualifier.nodeType){return jQuery.grep(elements,function(elem){return elem===qualifier!==not;});}if(typeof qualifier==="string"){if(risSimple.test(qualifier)){return jQuery.filter(qualifier,elements,not);}qualifier=jQuery.filter(qualifier,elements);}return jQuery.grep(elements,function(elem){return indexOf.call(qualifier,elem)>-1!==not&&elem.nodeType===1;});}jQuery.filter=function(expr,elems,not){var elem=elems[0];if(not){expr=":not("+expr+")";}return elems.length===1&&elem.nodeType===1?jQuery.find.matchesSelector(elem,expr)?[elem]:[]:jQuery.find.matches(expr,jQuery.grep(elems,function(elem){return elem.nodeType===1;}));};jQuery.fn.extend({find:function find(selector){var i,ret,len=this.length,self=this;if(typeof selector!=="string"){return this.pushStack(jQuery(selector).filter(function(){for(i=0;i<len;i++){if(jQuery.contains(self[i],this)){return true;}}}));}ret=this.pushStack([]);for(i=0;i<len;i++){jQuery.find(selector,self[i],ret);}return len>1?jQuery.uniqueSort(ret):ret;},filter:function filter(selector){return this.pushStack(winnow(this,selector||[],false));},not:function not(selector){return this.pushStack(winnow(this,selector||[],true));},is:function is(selector){return!!winnow(this,// If this is a positional/relative selector, check membership in the returned set
	// so $("p:first").is("p:last") won't return true for a doc with two "p".
	typeof selector==="string"&&rneedsContext.test(selector)?jQuery(selector):selector||[],false).length;}});// Initialize a jQuery object
	// A central reference to the root jQuery(document)
	var rootjQuery,// A simple way to check for HTML strings
	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
	// Strict HTML recognition (#11290: must start with <)
	// Shortcut simple #id case for speed
	rquickExpr=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,init=jQuery.fn.init=function(selector,context,root){var match,elem;// HANDLE: $(""), $(null), $(undefined), $(false)
	if(!selector){return this;}// Method init() accepts an alternate rootjQuery
	// so migrate can support jQuery.sub (gh-2101)
	root=root||rootjQuery;// Handle HTML strings
	if(typeof selector==="string"){if(selector[0]==="<"&&selector[selector.length-1]===">"&&selector.length>=3){// Assume that strings that start and end with <> are HTML and skip the regex check
	match=[null,selector,null];}else{match=rquickExpr.exec(selector);}// Match html or make sure no context is specified for #id
	if(match&&(match[1]||!context)){// HANDLE: $(html) -> $(array)
	if(match[1]){context=context instanceof jQuery?context[0]:context;// Option to run scripts is true for back-compat
	// Intentionally let the error be thrown if parseHTML is not present
	jQuery.merge(this,jQuery.parseHTML(match[1],context&&context.nodeType?context.ownerDocument||context:document,true));// HANDLE: $(html, props)
	if(rsingleTag.test(match[1])&&jQuery.isPlainObject(context)){for(match in context){// Properties of context are called as methods if possible
	if(jQuery.isFunction(this[match])){this[match](context[match]);// ...and otherwise set as attributes
	}else{this.attr(match,context[match]);}}}return this;// HANDLE: $(#id)
	}else{elem=document.getElementById(match[2]);if(elem){// Inject the element directly into the jQuery object
	this[0]=elem;this.length=1;}return this;}// HANDLE: $(expr, $(...))
	}else if(!context||context.jquery){return(context||root).find(selector);// HANDLE: $(expr, context)
	// (which is just equivalent to: $(context).find(expr)
	}else{return this.constructor(context).find(selector);}// HANDLE: $(DOMElement)
	}else if(selector.nodeType){this[0]=selector;this.length=1;return this;// HANDLE: $(function)
	// Shortcut for document ready
	}else if(jQuery.isFunction(selector)){return root.ready!==undefined?root.ready(selector):// Execute immediately if ready is not present
	selector(jQuery);}return jQuery.makeArray(selector,this);};// Give the init function the jQuery prototype for later instantiation
	init.prototype=jQuery.fn;// Initialize central reference
	rootjQuery=jQuery(document);var rparentsprev=/^(?:parents|prev(?:Until|All))/,// Methods guaranteed to produce a unique set when starting from a unique set
	guaranteedUnique={children:true,contents:true,next:true,prev:true};jQuery.fn.extend({has:function has(target){var targets=jQuery(target,this),l=targets.length;return this.filter(function(){var i=0;for(;i<l;i++){if(jQuery.contains(this,targets[i])){return true;}}});},closest:function closest(selectors,context){var cur,i=0,l=this.length,matched=[],targets=typeof selectors!=="string"&&jQuery(selectors);// Positional selectors never match, since there's no _selection_ context
	if(!rneedsContext.test(selectors)){for(;i<l;i++){for(cur=this[i];cur&&cur!==context;cur=cur.parentNode){// Always skip document fragments
	if(cur.nodeType<11&&(targets?targets.index(cur)>-1:// Don't pass non-elements to Sizzle
	cur.nodeType===1&&jQuery.find.matchesSelector(cur,selectors))){matched.push(cur);break;}}}}return this.pushStack(matched.length>1?jQuery.uniqueSort(matched):matched);},// Determine the position of an element within the set
	index:function index(elem){// No argument, return index in parent
	if(!elem){return this[0]&&this[0].parentNode?this.first().prevAll().length:-1;}// Index in selector
	if(typeof elem==="string"){return indexOf.call(jQuery(elem),this[0]);}// Locate the position of the desired element
	return indexOf.call(this,// If it receives a jQuery object, the first element is used
	elem.jquery?elem[0]:elem);},add:function add(selector,context){return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(),jQuery(selector,context))));},addBack:function addBack(selector){return this.add(selector==null?this.prevObject:this.prevObject.filter(selector));}});function sibling(cur,dir){while((cur=cur[dir])&&cur.nodeType!==1){}return cur;}jQuery.each({parent:function parent(elem){var parent=elem.parentNode;return parent&&parent.nodeType!==11?parent:null;},parents:function parents(elem){return dir(elem,"parentNode");},parentsUntil:function parentsUntil(elem,i,until){return dir(elem,"parentNode",until);},next:function next(elem){return sibling(elem,"nextSibling");},prev:function prev(elem){return sibling(elem,"previousSibling");},nextAll:function nextAll(elem){return dir(elem,"nextSibling");},prevAll:function prevAll(elem){return dir(elem,"previousSibling");},nextUntil:function nextUntil(elem,i,until){return dir(elem,"nextSibling",until);},prevUntil:function prevUntil(elem,i,until){return dir(elem,"previousSibling",until);},siblings:function siblings(elem){return _siblings((elem.parentNode||{}).firstChild,elem);},children:function children(elem){return _siblings(elem.firstChild);},contents:function contents(elem){return elem.contentDocument||jQuery.merge([],elem.childNodes);}},function(name,fn){jQuery.fn[name]=function(until,selector){var matched=jQuery.map(this,fn,until);if(name.slice(-5)!=="Until"){selector=until;}if(selector&&typeof selector==="string"){matched=jQuery.filter(selector,matched);}if(this.length>1){// Remove duplicates
	if(!guaranteedUnique[name]){jQuery.uniqueSort(matched);}// Reverse order for parents* and prev-derivatives
	if(rparentsprev.test(name)){matched.reverse();}}return this.pushStack(matched);};});var rnotwhite=/\S+/g;// Convert String-formatted options into Object-formatted ones
	function createOptions(options){var object={};jQuery.each(options.match(rnotwhite)||[],function(_,flag){object[flag]=true;});return object;}/*
	 * Create a callback list using the following parameters:
	 *
	 *	options: an optional list of space-separated options that will change how
	 *			the callback list behaves or a more traditional option object
	 *
	 * By default a callback list will act like an event callback list and can be
	 * "fired" multiple times.
	 *
	 * Possible options:
	 *
	 *	once:			will ensure the callback list can only be fired once (like a Deferred)
	 *
	 *	memory:			will keep track of previous values and will call any callback added
	 *					after the list has been fired right away with the latest "memorized"
	 *					values (like a Deferred)
	 *
	 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
	 *
	 *	stopOnFalse:	interrupt callings when a callback returns false
	 *
	 */jQuery.Callbacks=function(options){// Convert options from String-formatted to Object-formatted if needed
	// (we check in cache first)
	options=typeof options==="string"?createOptions(options):jQuery.extend({},options);var// Flag to know if list is currently firing
	firing,// Last fire value for non-forgettable lists
	memory,// Flag to know if list was already fired
	_fired,// Flag to prevent firing
	_locked,// Actual callback list
	list=[],// Queue of execution data for repeatable lists
	queue=[],// Index of currently firing callback (modified by add/remove as needed)
	firingIndex=-1,// Fire callbacks
	fire=function fire(){// Enforce single-firing
	_locked=options.once;// Execute callbacks for all pending executions,
	// respecting firingIndex overrides and runtime changes
	_fired=firing=true;for(;queue.length;firingIndex=-1){memory=queue.shift();while(++firingIndex<list.length){// Run callback and check for early termination
	if(list[firingIndex].apply(memory[0],memory[1])===false&&options.stopOnFalse){// Jump to end and forget the data so .add doesn't re-fire
	firingIndex=list.length;memory=false;}}}// Forget the data if we're done with it
	if(!options.memory){memory=false;}firing=false;// Clean up if we're done firing for good
	if(_locked){// Keep an empty list if we have data for future add calls
	if(memory){list=[];// Otherwise, this object is spent
	}else{list="";}}},// Actual Callbacks object
	self={// Add a callback or a collection of callbacks to the list
	add:function add(){if(list){// If we have memory from a past run, we should fire after adding
	if(memory&&!firing){firingIndex=list.length-1;queue.push(memory);}(function add(args){jQuery.each(args,function(_,arg){if(jQuery.isFunction(arg)){if(!options.unique||!self.has(arg)){list.push(arg);}}else if(arg&&arg.length&&jQuery.type(arg)!=="string"){// Inspect recursively
	add(arg);}});})(arguments);if(memory&&!firing){fire();}}return this;},// Remove a callback from the list
	remove:function remove(){jQuery.each(arguments,function(_,arg){var index;while((index=jQuery.inArray(arg,list,index))>-1){list.splice(index,1);// Handle firing indexes
	if(index<=firingIndex){firingIndex--;}}});return this;},// Check if a given callback is in the list.
	// If no argument is given, return whether or not list has callbacks attached.
	has:function has(fn){return fn?jQuery.inArray(fn,list)>-1:list.length>0;},// Remove all callbacks from the list
	empty:function empty(){if(list){list=[];}return this;},// Disable .fire and .add
	// Abort any current/pending executions
	// Clear all callbacks and values
	disable:function disable(){_locked=queue=[];list=memory="";return this;},disabled:function disabled(){return!list;},// Disable .fire
	// Also disable .add unless we have memory (since it would have no effect)
	// Abort any pending executions
	lock:function lock(){_locked=queue=[];if(!memory&&!firing){list=memory="";}return this;},locked:function locked(){return!!_locked;},// Call all callbacks with the given context and arguments
	fireWith:function fireWith(context,args){if(!_locked){args=args||[];args=[context,args.slice?args.slice():args];queue.push(args);if(!firing){fire();}}return this;},// Call all the callbacks with the given arguments
	fire:function fire(){self.fireWith(this,arguments);return this;},// To know if the callbacks have already been called at least once
	fired:function fired(){return!!_fired;}};return self;};function Identity(v){return v;}function Thrower(ex){throw ex;}function adoptValue(value,resolve,reject){var method;try{// Check for promise aspect first to privilege synchronous behavior
	if(value&&jQuery.isFunction(method=value.promise)){method.call(value).done(resolve).fail(reject);// Other thenables
	}else if(value&&jQuery.isFunction(method=value.then)){method.call(value,resolve,reject);// Other non-thenables
	}else{// Support: Android 4.0 only
	// Strict mode functions invoked without .call/.apply get global-object context
	resolve.call(undefined,value);}// For Promises/A+, convert exceptions into rejections
	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
	// Deferred#then to conditionally suppress rejection.
	}catch(/*jshint -W002 */value){// Support: Android 4.0 only
	// Strict mode functions invoked without .call/.apply get global-object context
	reject.call(undefined,value);}}jQuery.extend({Deferred:function Deferred(func){var tuples=[// action, add listener, callbacks,
	// ... .then handlers, argument index, [final state]
	["notify","progress",jQuery.Callbacks("memory"),jQuery.Callbacks("memory"),2],["resolve","done",jQuery.Callbacks("once memory"),jQuery.Callbacks("once memory"),0,"resolved"],["reject","fail",jQuery.Callbacks("once memory"),jQuery.Callbacks("once memory"),1,"rejected"]],_state="pending",_promise={state:function state(){return _state;},always:function always(){deferred.done(arguments).fail(arguments);return this;},"catch":function _catch(fn){return _promise.then(null,fn);},// Keep pipe for back-compat
	pipe:function pipe()/* fnDone, fnFail, fnProgress */{var fns=arguments;return jQuery.Deferred(function(newDefer){jQuery.each(tuples,function(i,tuple){// Map tuples (progress, done, fail) to arguments (done, fail, progress)
	var fn=jQuery.isFunction(fns[tuple[4]])&&fns[tuple[4]];// deferred.progress(function() { bind to newDefer or newDefer.notify })
	// deferred.done(function() { bind to newDefer or newDefer.resolve })
	// deferred.fail(function() { bind to newDefer or newDefer.reject })
	deferred[tuple[1]](function(){var returned=fn&&fn.apply(this,arguments);if(returned&&jQuery.isFunction(returned.promise)){returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);}else{newDefer[tuple[0]+"With"](this,fn?[returned]:arguments);}});});fns=null;}).promise();},then:function then(onFulfilled,onRejected,onProgress){var maxDepth=0;function resolve(depth,deferred,handler,special){return function(){var that=this,args=arguments,mightThrow=function mightThrow(){var returned,then;// Support: Promises/A+ section 2.3.3.3.3
	// https://promisesaplus.com/#point-59
	// Ignore double-resolution attempts
	if(depth<maxDepth){return;}returned=handler.apply(that,args);// Support: Promises/A+ section 2.3.1
	// https://promisesaplus.com/#point-48
	if(returned===deferred.promise()){throw new TypeError("Thenable self-resolution");}// Support: Promises/A+ sections 2.3.3.1, 3.5
	// https://promisesaplus.com/#point-54
	// https://promisesaplus.com/#point-75
	// Retrieve `then` only once
	then=returned&&(// Support: Promises/A+ section 2.3.4
	// https://promisesaplus.com/#point-64
	// Only check objects and functions for thenability
	(typeof returned==="undefined"?"undefined":_typeof(returned))==="object"||typeof returned==="function")&&returned.then;// Handle a returned thenable
	if(jQuery.isFunction(then)){// Special processors (notify) just wait for resolution
	if(special){then.call(returned,resolve(maxDepth,deferred,Identity,special),resolve(maxDepth,deferred,Thrower,special));// Normal processors (resolve) also hook into progress
	}else{// ...and disregard older resolution values
	maxDepth++;then.call(returned,resolve(maxDepth,deferred,Identity,special),resolve(maxDepth,deferred,Thrower,special),resolve(maxDepth,deferred,Identity,deferred.notifyWith));}// Handle all other returned values
	}else{// Only substitute handlers pass on context
	// and multiple values (non-spec behavior)
	if(handler!==Identity){that=undefined;args=[returned];}// Process the value(s)
	// Default process is resolve
	(special||deferred.resolveWith)(that,args);}},// Only normal processors (resolve) catch and reject exceptions
	process=special?mightThrow:function(){try{mightThrow();}catch(e){if(jQuery.Deferred.exceptionHook){jQuery.Deferred.exceptionHook(e,process.stackTrace);}// Support: Promises/A+ section 2.3.3.3.4.1
	// https://promisesaplus.com/#point-61
	// Ignore post-resolution exceptions
	if(depth+1>=maxDepth){// Only substitute handlers pass on context
	// and multiple values (non-spec behavior)
	if(handler!==Thrower){that=undefined;args=[e];}deferred.rejectWith(that,args);}}};// Support: Promises/A+ section 2.3.3.3.1
	// https://promisesaplus.com/#point-57
	// Re-resolve promises immediately to dodge false rejection from
	// subsequent errors
	if(depth){process();}else{// Call an optional hook to record the stack, in case of exception
	// since it's otherwise lost when execution goes async
	if(jQuery.Deferred.getStackHook){process.stackTrace=jQuery.Deferred.getStackHook();}window.setTimeout(process);}};}return jQuery.Deferred(function(newDefer){// progress_handlers.add( ... )
	tuples[0][3].add(resolve(0,newDefer,jQuery.isFunction(onProgress)?onProgress:Identity,newDefer.notifyWith));// fulfilled_handlers.add( ... )
	tuples[1][3].add(resolve(0,newDefer,jQuery.isFunction(onFulfilled)?onFulfilled:Identity));// rejected_handlers.add( ... )
	tuples[2][3].add(resolve(0,newDefer,jQuery.isFunction(onRejected)?onRejected:Thrower));}).promise();},// Get a promise for this deferred
	// If obj is provided, the promise aspect is added to the object
	promise:function promise(obj){return obj!=null?jQuery.extend(obj,_promise):_promise;}},deferred={};// Add list-specific methods
	jQuery.each(tuples,function(i,tuple){var list=tuple[2],stateString=tuple[5];// promise.progress = list.add
	// promise.done = list.add
	// promise.fail = list.add
	_promise[tuple[1]]=list.add;// Handle state
	if(stateString){list.add(function(){// state = "resolved" (i.e., fulfilled)
	// state = "rejected"
	_state=stateString;},// rejected_callbacks.disable
	// fulfilled_callbacks.disable
	tuples[3-i][2].disable,// progress_callbacks.lock
	tuples[0][2].lock);}// progress_handlers.fire
	// fulfilled_handlers.fire
	// rejected_handlers.fire
	list.add(tuple[3].fire);// deferred.notify = function() { deferred.notifyWith(...) }
	// deferred.resolve = function() { deferred.resolveWith(...) }
	// deferred.reject = function() { deferred.rejectWith(...) }
	deferred[tuple[0]]=function(){deferred[tuple[0]+"With"](this===deferred?undefined:this,arguments);return this;};// deferred.notifyWith = list.fireWith
	// deferred.resolveWith = list.fireWith
	// deferred.rejectWith = list.fireWith
	deferred[tuple[0]+"With"]=list.fireWith;});// Make the deferred a promise
	_promise.promise(deferred);// Call given func if any
	if(func){func.call(deferred,deferred);}// All done!
	return deferred;},// Deferred helper
	when:function when(singleValue){var// count of uncompleted subordinates
	remaining=arguments.length,// count of unprocessed arguments
	i=remaining,// subordinate fulfillment data
	resolveContexts=Array(i),resolveValues=_slice.call(arguments),// the master Deferred
	master=jQuery.Deferred(),// subordinate callback factory
	updateFunc=function updateFunc(i){return function(value){resolveContexts[i]=this;resolveValues[i]=arguments.length>1?_slice.call(arguments):value;if(! --remaining){master.resolveWith(resolveContexts,resolveValues);}};};// Single- and empty arguments are adopted like Promise.resolve
	if(remaining<=1){adoptValue(singleValue,master.done(updateFunc(i)).resolve,master.reject);// Use .then() to unwrap secondary thenables (cf. gh-3000)
	if(master.state()==="pending"||jQuery.isFunction(resolveValues[i]&&resolveValues[i].then)){return master.then();}}// Multiple arguments are aggregated like Promise.all array elements
	while(i--){adoptValue(resolveValues[i],updateFunc(i),master.reject);}return master.promise();}});// These usually indicate a programmer mistake during development,
	// warn about them ASAP rather than swallowing them by default.
	var rerrorNames=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;jQuery.Deferred.exceptionHook=function(error,stack){// Support: IE 8 - 9 only
	// Console exists when dev tools are open, which can happen at any time
	if(window.console&&window.console.warn&&error&&rerrorNames.test(error.name)){window.console.warn("jQuery.Deferred exception: "+error.message,error.stack,stack);}};// The deferred used on DOM ready
	var readyList=jQuery.Deferred();jQuery.fn.ready=function(fn){readyList.then(fn);return this;};jQuery.extend({// Is the DOM ready to be used? Set to true once it occurs.
	isReady:false,// A counter to track how many items to wait for before
	// the ready event fires. See #6781
	readyWait:1,// Hold (or release) the ready event
	holdReady:function holdReady(hold){if(hold){jQuery.readyWait++;}else{jQuery.ready(true);}},// Handle when the DOM is ready
	ready:function ready(wait){// Abort if there are pending holds or we're already ready
	if(wait===true?--jQuery.readyWait:jQuery.isReady){return;}// Remember that the DOM is ready
	jQuery.isReady=true;// If a normal DOM Ready event fired, decrement, and wait if need be
	if(wait!==true&&--jQuery.readyWait>0){return;}// If there are functions bound, to execute
	readyList.resolveWith(document,[jQuery]);}});jQuery.ready.then=readyList.then;// The ready event handler and self cleanup method
	function completed(){document.removeEventListener("DOMContentLoaded",completed);window.removeEventListener("load",completed);jQuery.ready();}// Catch cases where $(document).ready() is called
	// after the browser event has already occurred.
	// Support: IE <=9 - 10 only
	// Older IE sometimes signals "interactive" too soon
	if(document.readyState==="complete"||document.readyState!=="loading"&&!document.documentElement.doScroll){// Handle it asynchronously to allow scripts the opportunity to delay ready
	window.setTimeout(jQuery.ready);}else{// Use the handy event callback
	document.addEventListener("DOMContentLoaded",completed);// A fallback to window.onload, that will always work
	window.addEventListener("load",completed);}// Multifunctional method to get and set values of a collection
	// The value/s can optionally be executed if it's a function
	var access=function access(elems,fn,key,value,chainable,emptyGet,raw){var i=0,len=elems.length,bulk=key==null;// Sets many values
	if(jQuery.type(key)==="object"){chainable=true;for(i in key){access(elems,fn,i,key[i],true,emptyGet,raw);}// Sets one value
	}else if(value!==undefined){chainable=true;if(!jQuery.isFunction(value)){raw=true;}if(bulk){// Bulk operations run against the entire set
	if(raw){fn.call(elems,value);fn=null;// ...except when executing function values
	}else{bulk=fn;fn=function fn(elem,key,value){return bulk.call(jQuery(elem),value);};}}if(fn){for(;i<len;i++){fn(elems[i],key,raw?value:value.call(elems[i],i,fn(elems[i],key)));}}}return chainable?elems:// Gets
	bulk?fn.call(elems):len?fn(elems[0],key):emptyGet;};var acceptData=function acceptData(owner){// Accepts only:
	//  - Node
	//    - Node.ELEMENT_NODE
	//    - Node.DOCUMENT_NODE
	//  - Object
	//    - Any
	/* jshint -W018 */return owner.nodeType===1||owner.nodeType===9||!+owner.nodeType;};function Data(){this.expando=jQuery.expando+Data.uid++;}Data.uid=1;Data.prototype={cache:function cache(owner){// Check if the owner object already has a cache
	var value=owner[this.expando];// If not, create one
	if(!value){value={};// We can accept data for non-element nodes in modern browsers,
	// but we should not, see #8335.
	// Always return an empty object.
	if(acceptData(owner)){// If it is a node unlikely to be stringify-ed or looped over
	// use plain assignment
	if(owner.nodeType){owner[this.expando]=value;// Otherwise secure it in a non-enumerable property
	// configurable must be true to allow the property to be
	// deleted when data is removed
	}else{Object.defineProperty(owner,this.expando,{value:value,configurable:true});}}}return value;},set:function set(owner,data,value){var prop,cache=this.cache(owner);// Handle: [ owner, key, value ] args
	// Always use camelCase key (gh-2257)
	if(typeof data==="string"){cache[jQuery.camelCase(data)]=value;// Handle: [ owner, { properties } ] args
	}else{// Copy the properties one-by-one to the cache object
	for(prop in data){cache[jQuery.camelCase(prop)]=data[prop];}}return cache;},get:function get(owner,key){return key===undefined?this.cache(owner):// Always use camelCase key (gh-2257)
	owner[this.expando]&&owner[this.expando][jQuery.camelCase(key)];},access:function access(owner,key,value){// In cases where either:
	//
	//   1. No key was specified
	//   2. A string key was specified, but no value provided
	//
	// Take the "read" path and allow the get method to determine
	// which value to return, respectively either:
	//
	//   1. The entire cache object
	//   2. The data stored at the key
	//
	if(key===undefined||key&&typeof key==="string"&&value===undefined){return this.get(owner,key);}// When the key is not a string, or both a key and value
	// are specified, set or extend (existing objects) with either:
	//
	//   1. An object of properties
	//   2. A key and value
	//
	this.set(owner,key,value);// Since the "set" path can have two possible entry points
	// return the expected data based on which path was taken[*]
	return value!==undefined?value:key;},remove:function remove(owner,key){var i,cache=owner[this.expando];if(cache===undefined){return;}if(key!==undefined){// Support array or space separated string of keys
	if(jQuery.isArray(key)){// If key is an array of keys...
	// We always set camelCase keys, so remove that.
	key=key.map(jQuery.camelCase);}else{key=jQuery.camelCase(key);// If a key with the spaces exists, use it.
	// Otherwise, create an array by matching non-whitespace
	key=key in cache?[key]:key.match(rnotwhite)||[];}i=key.length;while(i--){delete cache[key[i]];}}// Remove the expando if there's no more data
	if(key===undefined||jQuery.isEmptyObject(cache)){// Support: Chrome <=35 - 45
	// Webkit & Blink performance suffers when deleting properties
	// from DOM nodes, so set to undefined instead
	// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
	if(owner.nodeType){owner[this.expando]=undefined;}else{delete owner[this.expando];}}},hasData:function hasData(owner){var cache=owner[this.expando];return cache!==undefined&&!jQuery.isEmptyObject(cache);}};var dataPriv=new Data();var dataUser=new Data();//	Implementation Summary
	//
	//	1. Enforce API surface and semantic compatibility with 1.9.x branch
	//	2. Improve the module's maintainability by reducing the storage
	//		paths to a single mechanism.
	//	3. Use the same single mechanism to support "private" and "user" data.
	//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
	//	5. Avoid exposing implementation details on user objects (eg. expando properties)
	//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
	var rbrace=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,rmultiDash=/[A-Z]/g;function dataAttr(elem,key,data){var name;// If nothing was found internally, try to fetch any
	// data from the HTML5 data-* attribute
	if(data===undefined&&elem.nodeType===1){name="data-"+key.replace(rmultiDash,"-$&").toLowerCase();data=elem.getAttribute(name);if(typeof data==="string"){try{data=data==="true"?true:data==="false"?false:data==="null"?null:// Only convert to a number if it doesn't change the string
	+data+""===data?+data:rbrace.test(data)?JSON.parse(data):data;}catch(e){}// Make sure we set the data so it isn't changed later
	dataUser.set(elem,key,data);}else{data=undefined;}}return data;}jQuery.extend({hasData:function hasData(elem){return dataUser.hasData(elem)||dataPriv.hasData(elem);},data:function data(elem,name,_data){return dataUser.access(elem,name,_data);},removeData:function removeData(elem,name){dataUser.remove(elem,name);},// TODO: Now that all calls to _data and _removeData have been replaced
	// with direct calls to dataPriv methods, these can be deprecated.
	_data:function _data(elem,name,data){return dataPriv.access(elem,name,data);},_removeData:function _removeData(elem,name){dataPriv.remove(elem,name);}});jQuery.fn.extend({data:function data(key,value){var i,name,data,elem=this[0],attrs=elem&&elem.attributes;// Gets all values
	if(key===undefined){if(this.length){data=dataUser.get(elem);if(elem.nodeType===1&&!dataPriv.get(elem,"hasDataAttrs")){i=attrs.length;while(i--){// Support: IE 11 only
	// The attrs elements can be null (#14894)
	if(attrs[i]){name=attrs[i].name;if(name.indexOf("data-")===0){name=jQuery.camelCase(name.slice(5));dataAttr(elem,name,data[name]);}}}dataPriv.set(elem,"hasDataAttrs",true);}}return data;}// Sets multiple values
	if((typeof key==="undefined"?"undefined":_typeof(key))==="object"){return this.each(function(){dataUser.set(this,key);});}return access(this,function(value){var data;// The calling jQuery object (element matches) is not empty
	// (and therefore has an element appears at this[ 0 ]) and the
	// `value` parameter was not undefined. An empty jQuery object
	// will result in `undefined` for elem = this[ 0 ] which will
	// throw an exception if an attempt to read a data cache is made.
	if(elem&&value===undefined){// Attempt to get data from the cache
	// The key will always be camelCased in Data
	data=dataUser.get(elem,key);if(data!==undefined){return data;}// Attempt to "discover" the data in
	// HTML5 custom data-* attrs
	data=dataAttr(elem,key);if(data!==undefined){return data;}// We tried really hard, but the data doesn't exist.
	return;}// Set the data...
	this.each(function(){// We always store the camelCased key
	dataUser.set(this,key,value);});},null,value,arguments.length>1,null,true);},removeData:function removeData(key){return this.each(function(){dataUser.remove(this,key);});}});jQuery.extend({queue:function queue(elem,type,data){var queue;if(elem){type=(type||"fx")+"queue";queue=dataPriv.get(elem,type);// Speed up dequeue by getting out quickly if this is just a lookup
	if(data){if(!queue||jQuery.isArray(data)){queue=dataPriv.access(elem,type,jQuery.makeArray(data));}else{queue.push(data);}}return queue||[];}},dequeue:function dequeue(elem,type){type=type||"fx";var queue=jQuery.queue(elem,type),startLength=queue.length,fn=queue.shift(),hooks=jQuery._queueHooks(elem,type),next=function next(){jQuery.dequeue(elem,type);};// If the fx queue is dequeued, always remove the progress sentinel
	if(fn==="inprogress"){fn=queue.shift();startLength--;}if(fn){// Add a progress sentinel to prevent the fx queue from being
	// automatically dequeued
	if(type==="fx"){queue.unshift("inprogress");}// Clear up the last queue stop function
	delete hooks.stop;fn.call(elem,next,hooks);}if(!startLength&&hooks){hooks.empty.fire();}},// Not public - generate a queueHooks object, or return the current one
	_queueHooks:function _queueHooks(elem,type){var key=type+"queueHooks";return dataPriv.get(elem,key)||dataPriv.access(elem,key,{empty:jQuery.Callbacks("once memory").add(function(){dataPriv.remove(elem,[type+"queue",key]);})});}});jQuery.fn.extend({queue:function queue(type,data){var setter=2;if(typeof type!=="string"){data=type;type="fx";setter--;}if(arguments.length<setter){return jQuery.queue(this[0],type);}return data===undefined?this:this.each(function(){var queue=jQuery.queue(this,type,data);// Ensure a hooks for this queue
	jQuery._queueHooks(this,type);if(type==="fx"&&queue[0]!=="inprogress"){jQuery.dequeue(this,type);}});},dequeue:function dequeue(type){return this.each(function(){jQuery.dequeue(this,type);});},clearQueue:function clearQueue(type){return this.queue(type||"fx",[]);},// Get a promise resolved when queues of a certain type
	// are emptied (fx is the type by default)
	promise:function promise(type,obj){var tmp,count=1,defer=jQuery.Deferred(),elements=this,i=this.length,resolve=function resolve(){if(! --count){defer.resolveWith(elements,[elements]);}};if(typeof type!=="string"){obj=type;type=undefined;}type=type||"fx";while(i--){tmp=dataPriv.get(elements[i],type+"queueHooks");if(tmp&&tmp.empty){count++;tmp.empty.add(resolve);}}resolve();return defer.promise(obj);}});var pnum=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;var rcssNum=new RegExp("^(?:([+-])=|)("+pnum+")([a-z%]*)$","i");var cssExpand=["Top","Right","Bottom","Left"];var isHiddenWithinTree=function isHiddenWithinTree(elem,el){// isHiddenWithinTree might be called from jQuery#filter function;
	// in that case, element will be second argument
	elem=el||elem;// Inline style trumps all
	return elem.style.display==="none"||elem.style.display===""&&// Otherwise, check computed style
	// Support: Firefox <=43 - 45
	// Disconnected elements can have computed display: none, so first confirm that elem is
	// in the document.
	jQuery.contains(elem.ownerDocument,elem)&&jQuery.css(elem,"display")==="none";};var swap=function swap(elem,options,callback,args){var ret,name,old={};// Remember the old values, and insert the new ones
	for(name in options){old[name]=elem.style[name];elem.style[name]=options[name];}ret=callback.apply(elem,args||[]);// Revert the old values
	for(name in options){elem.style[name]=old[name];}return ret;};function adjustCSS(elem,prop,valueParts,tween){var adjusted,scale=1,maxIterations=20,currentValue=tween?function(){return tween.cur();}:function(){return jQuery.css(elem,prop,"");},initial=currentValue(),unit=valueParts&&valueParts[3]||(jQuery.cssNumber[prop]?"":"px"),// Starting value computation is required for potential unit mismatches
	initialInUnit=(jQuery.cssNumber[prop]||unit!=="px"&&+initial)&&rcssNum.exec(jQuery.css(elem,prop));if(initialInUnit&&initialInUnit[3]!==unit){// Trust units reported by jQuery.css
	unit=unit||initialInUnit[3];// Make sure we update the tween properties later on
	valueParts=valueParts||[];// Iteratively approximate from a nonzero starting point
	initialInUnit=+initial||1;do{// If previous iteration zeroed out, double until we get *something*.
	// Use string for doubling so we don't accidentally see scale as unchanged below
	scale=scale||".5";// Adjust and apply
	initialInUnit=initialInUnit/scale;jQuery.style(elem,prop,initialInUnit+unit);// Update scale, tolerating zero or NaN from tween.cur()
	// Break the loop if scale is unchanged or perfect, or if we've just had enough.
	}while(scale!==(scale=currentValue()/initial)&&scale!==1&&--maxIterations);}if(valueParts){initialInUnit=+initialInUnit||+initial||0;// Apply relative offset (+=/-=) if specified
	adjusted=valueParts[1]?initialInUnit+(valueParts[1]+1)*valueParts[2]:+valueParts[2];if(tween){tween.unit=unit;tween.start=initialInUnit;tween.end=adjusted;}}return adjusted;}var defaultDisplayMap={};function getDefaultDisplay(elem){var temp,doc=elem.ownerDocument,nodeName=elem.nodeName,display=defaultDisplayMap[nodeName];if(display){return display;}temp=doc.body.appendChild(doc.createElement(nodeName)),display=jQuery.css(temp,"display");temp.parentNode.removeChild(temp);if(display==="none"){display="block";}defaultDisplayMap[nodeName]=display;return display;}function showHide(elements,show){var display,elem,values=[],index=0,length=elements.length;// Determine new display value for elements that need to change
	for(;index<length;index++){elem=elements[index];if(!elem.style){continue;}display=elem.style.display;if(show){// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
	// check is required in this first loop unless we have a nonempty display value (either
	// inline or about-to-be-restored)
	if(display==="none"){values[index]=dataPriv.get(elem,"display")||null;if(!values[index]){elem.style.display="";}}if(elem.style.display===""&&isHiddenWithinTree(elem)){values[index]=getDefaultDisplay(elem);}}else{if(display!=="none"){values[index]="none";// Remember what we're overwriting
	dataPriv.set(elem,"display",display);}}}// Set the display of the elements in a second loop to avoid constant reflow
	for(index=0;index<length;index++){if(values[index]!=null){elements[index].style.display=values[index];}}return elements;}jQuery.fn.extend({show:function show(){return showHide(this,true);},hide:function hide(){return showHide(this);},toggle:function toggle(state){if(typeof state==="boolean"){return state?this.show():this.hide();}return this.each(function(){if(isHiddenWithinTree(this)){jQuery(this).show();}else{jQuery(this).hide();}});}});var rcheckableType=/^(?:checkbox|radio)$/i;var rtagName=/<([a-z][^\/\0>\x20\t\r\n\f]+)/i;var rscriptType=/^$|\/(?:java|ecma)script/i;// We have to close these tags to support XHTML (#13200)
	var wrapMap={// Support: IE <=9 only
	option:[1,"<select multiple='multiple'>","</select>"],// XHTML parsers do not magically insert elements in the
	// same way that tag soup parsers do. So we cannot shorten
	// this by omitting <tbody> or other required elements.
	thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};// Support: IE <=9 only
	wrapMap.optgroup=wrapMap.option;wrapMap.tbody=wrapMap.tfoot=wrapMap.colgroup=wrapMap.caption=wrapMap.thead;wrapMap.th=wrapMap.td;function getAll(context,tag){// Support: IE <=9 - 11 only
	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
	var ret=typeof context.getElementsByTagName!=="undefined"?context.getElementsByTagName(tag||"*"):typeof context.querySelectorAll!=="undefined"?context.querySelectorAll(tag||"*"):[];return tag===undefined||tag&&jQuery.nodeName(context,tag)?jQuery.merge([context],ret):ret;}// Mark scripts as having already been evaluated
	function setGlobalEval(elems,refElements){var i=0,l=elems.length;for(;i<l;i++){dataPriv.set(elems[i],"globalEval",!refElements||dataPriv.get(refElements[i],"globalEval"));}}var rhtml=/<|&#?\w+;/;function buildFragment(elems,context,scripts,selection,ignored){var elem,tmp,tag,wrap,contains,j,fragment=context.createDocumentFragment(),nodes=[],i=0,l=elems.length;for(;i<l;i++){elem=elems[i];if(elem||elem===0){// Add nodes directly
	if(jQuery.type(elem)==="object"){// Support: Android <=4.0 only, PhantomJS 1 only
	// push.apply(_, arraylike) throws on ancient WebKit
	jQuery.merge(nodes,elem.nodeType?[elem]:elem);// Convert non-html into a text node
	}else if(!rhtml.test(elem)){nodes.push(context.createTextNode(elem));// Convert html into DOM nodes
	}else{tmp=tmp||fragment.appendChild(context.createElement("div"));// Deserialize a standard representation
	tag=(rtagName.exec(elem)||["",""])[1].toLowerCase();wrap=wrapMap[tag]||wrapMap._default;tmp.innerHTML=wrap[1]+jQuery.htmlPrefilter(elem)+wrap[2];// Descend through wrappers to the right content
	j=wrap[0];while(j--){tmp=tmp.lastChild;}// Support: Android <=4.0 only, PhantomJS 1 only
	// push.apply(_, arraylike) throws on ancient WebKit
	jQuery.merge(nodes,tmp.childNodes);// Remember the top-level container
	tmp=fragment.firstChild;// Ensure the created nodes are orphaned (#12392)
	tmp.textContent="";}}}// Remove wrapper from fragment
	fragment.textContent="";i=0;while(elem=nodes[i++]){// Skip elements already in the context collection (trac-4087)
	if(selection&&jQuery.inArray(elem,selection)>-1){if(ignored){ignored.push(elem);}continue;}contains=jQuery.contains(elem.ownerDocument,elem);// Append to fragment
	tmp=getAll(fragment.appendChild(elem),"script");// Preserve script evaluation history
	if(contains){setGlobalEval(tmp);}// Capture executables
	if(scripts){j=0;while(elem=tmp[j++]){if(rscriptType.test(elem.type||"")){scripts.push(elem);}}}}return fragment;}(function(){var fragment=document.createDocumentFragment(),div=fragment.appendChild(document.createElement("div")),input=document.createElement("input");// Support: Android 4.0 - 4.3 only
	// Check state lost if the name is set (#11217)
	// Support: Windows Web Apps (WWA)
	// `name` and `type` must use .setAttribute for WWA (#14901)
	input.setAttribute("type","radio");input.setAttribute("checked","checked");input.setAttribute("name","t");div.appendChild(input);// Support: Android <=4.1 only
	// Older WebKit doesn't clone checked state correctly in fragments
	support.checkClone=div.cloneNode(true).cloneNode(true).lastChild.checked;// Support: IE <=11 only
	// Make sure textarea (and checkbox) defaultValue is properly cloned
	div.innerHTML="<textarea>x</textarea>";support.noCloneChecked=!!div.cloneNode(true).lastChild.defaultValue;})();var documentElement=document.documentElement;var rkeyEvent=/^key/,rmouseEvent=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,rtypenamespace=/^([^.]*)(?:\.(.+)|)/;function returnTrue(){return true;}function returnFalse(){return false;}// Support: IE <=9 only
	// See #13393 for more info
	function safeActiveElement(){try{return document.activeElement;}catch(err){}}function _on(elem,types,selector,data,fn,one){var origFn,type;// Types can be a map of types/handlers
	if((typeof types==="undefined"?"undefined":_typeof(types))==="object"){// ( types-Object, selector, data )
	if(typeof selector!=="string"){// ( types-Object, data )
	data=data||selector;selector=undefined;}for(type in types){_on(elem,type,selector,data,types[type],one);}return elem;}if(data==null&&fn==null){// ( types, fn )
	fn=selector;data=selector=undefined;}else if(fn==null){if(typeof selector==="string"){// ( types, selector, fn )
	fn=data;data=undefined;}else{// ( types, data, fn )
	fn=data;data=selector;selector=undefined;}}if(fn===false){fn=returnFalse;}else if(!fn){return elem;}if(one===1){origFn=fn;fn=function fn(event){// Can use an empty set, since event contains the info
	jQuery().off(event);return origFn.apply(this,arguments);};// Use same guid so caller can remove using origFn
	fn.guid=origFn.guid||(origFn.guid=jQuery.guid++);}return elem.each(function(){jQuery.event.add(this,types,fn,data,selector);});}/*
	 * Helper functions for managing events -- not part of the public interface.
	 * Props to Dean Edwards' addEvent library for many of the ideas.
	 */jQuery.event={global:{},add:function add(elem,types,handler,data,selector){var handleObjIn,eventHandle,tmp,events,t,handleObj,special,handlers,type,namespaces,origType,elemData=dataPriv.get(elem);// Don't attach events to noData or text/comment nodes (but allow plain objects)
	if(!elemData){return;}// Caller can pass in an object of custom data in lieu of the handler
	if(handler.handler){handleObjIn=handler;handler=handleObjIn.handler;selector=handleObjIn.selector;}// Ensure that invalid selectors throw exceptions at attach time
	// Evaluate against documentElement in case elem is a non-element node (e.g., document)
	if(selector){jQuery.find.matchesSelector(documentElement,selector);}// Make sure that the handler has a unique ID, used to find/remove it later
	if(!handler.guid){handler.guid=jQuery.guid++;}// Init the element's event structure and main handler, if this is the first
	if(!(events=elemData.events)){events=elemData.events={};}if(!(eventHandle=elemData.handle)){eventHandle=elemData.handle=function(e){// Discard the second event of a jQuery.event.trigger() and
	// when an event is called after a page has unloaded
	return typeof jQuery!=="undefined"&&jQuery.event.triggered!==e.type?jQuery.event.dispatch.apply(elem,arguments):undefined;};}// Handle multiple events separated by a space
	types=(types||"").match(rnotwhite)||[""];t=types.length;while(t--){tmp=rtypenamespace.exec(types[t])||[];type=origType=tmp[1];namespaces=(tmp[2]||"").split(".").sort();// There *must* be a type, no attaching namespace-only handlers
	if(!type){continue;}// If event changes its type, use the special event handlers for the changed type
	special=jQuery.event.special[type]||{};// If selector defined, determine special event api type, otherwise given type
	type=(selector?special.delegateType:special.bindType)||type;// Update special based on newly reset type
	special=jQuery.event.special[type]||{};// handleObj is passed to all event handlers
	handleObj=jQuery.extend({type:type,origType:origType,data:data,handler:handler,guid:handler.guid,selector:selector,needsContext:selector&&jQuery.expr.match.needsContext.test(selector),namespace:namespaces.join(".")},handleObjIn);// Init the event handler queue if we're the first
	if(!(handlers=events[type])){handlers=events[type]=[];handlers.delegateCount=0;// Only use addEventListener if the special events handler returns false
	if(!special.setup||special.setup.call(elem,data,namespaces,eventHandle)===false){if(elem.addEventListener){elem.addEventListener(type,eventHandle);}}}if(special.add){special.add.call(elem,handleObj);if(!handleObj.handler.guid){handleObj.handler.guid=handler.guid;}}// Add to the element's handler list, delegates in front
	if(selector){handlers.splice(handlers.delegateCount++,0,handleObj);}else{handlers.push(handleObj);}// Keep track of which events have ever been used, for event optimization
	jQuery.event.global[type]=true;}},// Detach an event or set of events from an element
	remove:function remove(elem,types,handler,selector,mappedTypes){var j,origCount,tmp,events,t,handleObj,special,handlers,type,namespaces,origType,elemData=dataPriv.hasData(elem)&&dataPriv.get(elem);if(!elemData||!(events=elemData.events)){return;}// Once for each type.namespace in types; type may be omitted
	types=(types||"").match(rnotwhite)||[""];t=types.length;while(t--){tmp=rtypenamespace.exec(types[t])||[];type=origType=tmp[1];namespaces=(tmp[2]||"").split(".").sort();// Unbind all events (on this namespace, if provided) for the element
	if(!type){for(type in events){jQuery.event.remove(elem,type+types[t],handler,selector,true);}continue;}special=jQuery.event.special[type]||{};type=(selector?special.delegateType:special.bindType)||type;handlers=events[type]||[];tmp=tmp[2]&&new RegExp("(^|\\.)"+namespaces.join("\\.(?:.*\\.|)")+"(\\.|$)");// Remove matching events
	origCount=j=handlers.length;while(j--){handleObj=handlers[j];if((mappedTypes||origType===handleObj.origType)&&(!handler||handler.guid===handleObj.guid)&&(!tmp||tmp.test(handleObj.namespace))&&(!selector||selector===handleObj.selector||selector==="**"&&handleObj.selector)){handlers.splice(j,1);if(handleObj.selector){handlers.delegateCount--;}if(special.remove){special.remove.call(elem,handleObj);}}}// Remove generic event handler if we removed something and no more handlers exist
	// (avoids potential for endless recursion during removal of special event handlers)
	if(origCount&&!handlers.length){if(!special.teardown||special.teardown.call(elem,namespaces,elemData.handle)===false){jQuery.removeEvent(elem,type,elemData.handle);}delete events[type];}}// Remove data and the expando if it's no longer used
	if(jQuery.isEmptyObject(events)){dataPriv.remove(elem,"handle events");}},dispatch:function dispatch(nativeEvent){// Make a writable jQuery.Event from the native event object
	var event=jQuery.event.fix(nativeEvent);var i,j,ret,matched,handleObj,handlerQueue,args=new Array(arguments.length),handlers=(dataPriv.get(this,"events")||{})[event.type]||[],special=jQuery.event.special[event.type]||{};// Use the fix-ed jQuery.Event rather than the (read-only) native event
	args[0]=event;for(i=1;i<arguments.length;i++){args[i]=arguments[i];}event.delegateTarget=this;// Call the preDispatch hook for the mapped type, and let it bail if desired
	if(special.preDispatch&&special.preDispatch.call(this,event)===false){return;}// Determine handlers
	handlerQueue=jQuery.event.handlers.call(this,event,handlers);// Run delegates first; they may want to stop propagation beneath us
	i=0;while((matched=handlerQueue[i++])&&!event.isPropagationStopped()){event.currentTarget=matched.elem;j=0;while((handleObj=matched.handlers[j++])&&!event.isImmediatePropagationStopped()){// Triggered event must either 1) have no namespace, or 2) have namespace(s)
	// a subset or equal to those in the bound event (both can have no namespace).
	if(!event.rnamespace||event.rnamespace.test(handleObj.namespace)){event.handleObj=handleObj;event.data=handleObj.data;ret=((jQuery.event.special[handleObj.origType]||{}).handle||handleObj.handler).apply(matched.elem,args);if(ret!==undefined){if((event.result=ret)===false){event.preventDefault();event.stopPropagation();}}}}}// Call the postDispatch hook for the mapped type
	if(special.postDispatch){special.postDispatch.call(this,event);}return event.result;},handlers:function handlers(event,_handlers){var i,matches,sel,handleObj,handlerQueue=[],delegateCount=_handlers.delegateCount,cur=event.target;// Support: IE <=9
	// Find delegate handlers
	// Black-hole SVG <use> instance trees (#13180)
	//
	// Support: Firefox <=42
	// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
	if(delegateCount&&cur.nodeType&&(event.type!=="click"||isNaN(event.button)||event.button<1)){for(;cur!==this;cur=cur.parentNode||this){// Don't check non-elements (#13208)
	// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
	if(cur.nodeType===1&&(cur.disabled!==true||event.type!=="click")){matches=[];for(i=0;i<delegateCount;i++){handleObj=_handlers[i];// Don't conflict with Object.prototype properties (#13203)
	sel=handleObj.selector+" ";if(matches[sel]===undefined){matches[sel]=handleObj.needsContext?jQuery(sel,this).index(cur)>-1:jQuery.find(sel,this,null,[cur]).length;}if(matches[sel]){matches.push(handleObj);}}if(matches.length){handlerQueue.push({elem:cur,handlers:matches});}}}}// Add the remaining (directly-bound) handlers
	if(delegateCount<_handlers.length){handlerQueue.push({elem:this,handlers:_handlers.slice(delegateCount)});}return handlerQueue;},addProp:function addProp(name,hook){Object.defineProperty(jQuery.Event.prototype,name,{enumerable:true,configurable:true,get:jQuery.isFunction(hook)?function(){if(this.originalEvent){return hook(this.originalEvent);}}:function(){if(this.originalEvent){return this.originalEvent[name];}},set:function set(value){Object.defineProperty(this,name,{enumerable:true,configurable:true,writable:true,value:value});}});},fix:function fix(originalEvent){return originalEvent[jQuery.expando]?originalEvent:new jQuery.Event(originalEvent);},special:{load:{// Prevent triggered image.load events from bubbling to window.load
	noBubble:true},focus:{// Fire native event if possible so blur/focus sequence is correct
	trigger:function trigger(){if(this!==safeActiveElement()&&this.focus){this.focus();return false;}},delegateType:"focusin"},blur:{trigger:function trigger(){if(this===safeActiveElement()&&this.blur){this.blur();return false;}},delegateType:"focusout"},click:{// For checkbox, fire native event so checked state will be right
	trigger:function trigger(){if(this.type==="checkbox"&&this.click&&jQuery.nodeName(this,"input")){this.click();return false;}},// For cross-browser consistency, don't fire native .click() on links
	_default:function _default(event){return jQuery.nodeName(event.target,"a");}},beforeunload:{postDispatch:function postDispatch(event){// Support: Firefox 20+
	// Firefox doesn't alert if the returnValue field is not set.
	if(event.result!==undefined&&event.originalEvent){event.originalEvent.returnValue=event.result;}}}}};jQuery.removeEvent=function(elem,type,handle){// This "if" is needed for plain objects
	if(elem.removeEventListener){elem.removeEventListener(type,handle);}};jQuery.Event=function(src,props){// Allow instantiation without the 'new' keyword
	if(!(this instanceof jQuery.Event)){return new jQuery.Event(src,props);}// Event object
	if(src&&src.type){this.originalEvent=src;this.type=src.type;// Events bubbling up the document may have been marked as prevented
	// by a handler lower down the tree; reflect the correct value.
	this.isDefaultPrevented=src.defaultPrevented||src.defaultPrevented===undefined&&// Support: Android <=2.3 only
	src.returnValue===false?returnTrue:returnFalse;// Create target properties
	// Support: Safari <=6 - 7 only
	// Target should not be a text node (#504, #13143)
	this.target=src.target&&src.target.nodeType===3?src.target.parentNode:src.target;this.currentTarget=src.currentTarget;this.relatedTarget=src.relatedTarget;// Event type
	}else{this.type=src;}// Put explicitly provided properties onto the event object
	if(props){jQuery.extend(this,props);}// Create a timestamp if incoming event doesn't have one
	this.timeStamp=src&&src.timeStamp||jQuery.now();// Mark it as fixed
	this[jQuery.expando]=true;};// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
	// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
	jQuery.Event.prototype={constructor:jQuery.Event,isDefaultPrevented:returnFalse,isPropagationStopped:returnFalse,isImmediatePropagationStopped:returnFalse,isSimulated:false,preventDefault:function preventDefault(){var e=this.originalEvent;this.isDefaultPrevented=returnTrue;if(e&&!this.isSimulated){e.preventDefault();}},stopPropagation:function stopPropagation(){var e=this.originalEvent;this.isPropagationStopped=returnTrue;if(e&&!this.isSimulated){e.stopPropagation();}},stopImmediatePropagation:function stopImmediatePropagation(){var e=this.originalEvent;this.isImmediatePropagationStopped=returnTrue;if(e&&!this.isSimulated){e.stopImmediatePropagation();}this.stopPropagation();}};// Includes all common event props including KeyEvent and MouseEvent specific props
	jQuery.each({altKey:true,bubbles:true,cancelable:true,changedTouches:true,ctrlKey:true,detail:true,eventPhase:true,metaKey:true,pageX:true,pageY:true,shiftKey:true,view:true,"char":true,charCode:true,key:true,keyCode:true,button:true,buttons:true,clientX:true,clientY:true,offsetX:true,offsetY:true,pointerId:true,pointerType:true,screenX:true,screenY:true,targetTouches:true,toElement:true,touches:true,which:function which(event){var button=event.button;// Add which for key events
	if(event.which==null&&rkeyEvent.test(event.type)){return event.charCode!=null?event.charCode:event.keyCode;}// Add which for click: 1 === left; 2 === middle; 3 === right
	if(!event.which&&button!==undefined&&rmouseEvent.test(event.type)){return button&1?1:button&2?3:button&4?2:0;}return event.which;}},jQuery.event.addProp);// Create mouseenter/leave events using mouseover/out and event-time checks
	// so that event delegation works in jQuery.
	// Do the same for pointerenter/pointerleave and pointerover/pointerout
	//
	// Support: Safari 7 only
	// Safari sends mouseenter too often; see:
	// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
	// for the description of the bug (it existed in older Chrome versions as well).
	jQuery.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(orig,fix){jQuery.event.special[orig]={delegateType:fix,bindType:fix,handle:function handle(event){var ret,target=this,related=event.relatedTarget,handleObj=event.handleObj;// For mouseenter/leave call the handler if related is outside the target.
	// NB: No relatedTarget if the mouse left/entered the browser window
	if(!related||related!==target&&!jQuery.contains(target,related)){event.type=handleObj.origType;ret=handleObj.handler.apply(this,arguments);event.type=fix;}return ret;}};});jQuery.fn.extend({on:function on(types,selector,data,fn){return _on(this,types,selector,data,fn);},one:function one(types,selector,data,fn){return _on(this,types,selector,data,fn,1);},off:function off(types,selector,fn){var handleObj,type;if(types&&types.preventDefault&&types.handleObj){// ( event )  dispatched jQuery.Event
	handleObj=types.handleObj;jQuery(types.delegateTarget).off(handleObj.namespace?handleObj.origType+"."+handleObj.namespace:handleObj.origType,handleObj.selector,handleObj.handler);return this;}if((typeof types==="undefined"?"undefined":_typeof(types))==="object"){// ( types-object [, selector] )
	for(type in types){this.off(type,selector,types[type]);}return this;}if(selector===false||typeof selector==="function"){// ( types [, fn] )
	fn=selector;selector=undefined;}if(fn===false){fn=returnFalse;}return this.each(function(){jQuery.event.remove(this,types,fn,selector);});}});var rxhtmlTag=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,// Support: IE <=10 - 11, Edge 12 - 13
	// In IE/Edge using regex groups here causes severe slowdowns.
	// See https://connect.microsoft.com/IE/feedback/details/1736512/
	rnoInnerhtml=/<script|<style|<link/i,// checked="checked" or checked
	rchecked=/checked\s*(?:[^=]|=\s*.checked.)/i,rscriptTypeMasked=/^true\/(.*)/,rcleanScript=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;function manipulationTarget(elem,content){if(jQuery.nodeName(elem,"table")&&jQuery.nodeName(content.nodeType!==11?content:content.firstChild,"tr")){return elem.getElementsByTagName("tbody")[0]||elem;}return elem;}// Replace/restore the type attribute of script elements for safe DOM manipulation
	function disableScript(elem){elem.type=(elem.getAttribute("type")!==null)+"/"+elem.type;return elem;}function restoreScript(elem){var match=rscriptTypeMasked.exec(elem.type);if(match){elem.type=match[1];}else{elem.removeAttribute("type");}return elem;}function cloneCopyEvent(src,dest){var i,l,type,pdataOld,pdataCur,udataOld,udataCur,events;if(dest.nodeType!==1){return;}// 1. Copy private data: events, handlers, etc.
	if(dataPriv.hasData(src)){pdataOld=dataPriv.access(src);pdataCur=dataPriv.set(dest,pdataOld);events=pdataOld.events;if(events){delete pdataCur.handle;pdataCur.events={};for(type in events){for(i=0,l=events[type].length;i<l;i++){jQuery.event.add(dest,type,events[type][i]);}}}}// 2. Copy user data
	if(dataUser.hasData(src)){udataOld=dataUser.access(src);udataCur=jQuery.extend({},udataOld);dataUser.set(dest,udataCur);}}// Fix IE bugs, see support tests
	function fixInput(src,dest){var nodeName=dest.nodeName.toLowerCase();// Fails to persist the checked state of a cloned checkbox or radio button.
	if(nodeName==="input"&&rcheckableType.test(src.type)){dest.checked=src.checked;// Fails to return the selected option to the default selected state when cloning options
	}else if(nodeName==="input"||nodeName==="textarea"){dest.defaultValue=src.defaultValue;}}function domManip(collection,args,callback,ignored){// Flatten any nested arrays
	args=concat.apply([],args);var fragment,first,scripts,hasScripts,node,doc,i=0,l=collection.length,iNoClone=l-1,value=args[0],isFunction=jQuery.isFunction(value);// We can't cloneNode fragments that contain checked, in WebKit
	if(isFunction||l>1&&typeof value==="string"&&!support.checkClone&&rchecked.test(value)){return collection.each(function(index){var self=collection.eq(index);if(isFunction){args[0]=value.call(this,index,self.html());}domManip(self,args,callback,ignored);});}if(l){fragment=buildFragment(args,collection[0].ownerDocument,false,collection,ignored);first=fragment.firstChild;if(fragment.childNodes.length===1){fragment=first;}// Require either new content or an interest in ignored elements to invoke the callback
	if(first||ignored){scripts=jQuery.map(getAll(fragment,"script"),disableScript);hasScripts=scripts.length;// Use the original fragment for the last item
	// instead of the first because it can end up
	// being emptied incorrectly in certain situations (#8070).
	for(;i<l;i++){node=fragment;if(i!==iNoClone){node=jQuery.clone(node,true,true);// Keep references to cloned scripts for later restoration
	if(hasScripts){// Support: Android <=4.0 only, PhantomJS 1 only
	// push.apply(_, arraylike) throws on ancient WebKit
	jQuery.merge(scripts,getAll(node,"script"));}}callback.call(collection[i],node,i);}if(hasScripts){doc=scripts[scripts.length-1].ownerDocument;// Reenable scripts
	jQuery.map(scripts,restoreScript);// Evaluate executable scripts on first document insertion
	for(i=0;i<hasScripts;i++){node=scripts[i];if(rscriptType.test(node.type||"")&&!dataPriv.access(node,"globalEval")&&jQuery.contains(doc,node)){if(node.src){// Optional AJAX dependency, but won't run scripts if not present
	if(jQuery._evalUrl){jQuery._evalUrl(node.src);}}else{DOMEval(node.textContent.replace(rcleanScript,""),doc);}}}}}}return collection;}function _remove(elem,selector,keepData){var node,nodes=selector?jQuery.filter(selector,elem):elem,i=0;for(;(node=nodes[i])!=null;i++){if(!keepData&&node.nodeType===1){jQuery.cleanData(getAll(node));}if(node.parentNode){if(keepData&&jQuery.contains(node.ownerDocument,node)){setGlobalEval(getAll(node,"script"));}node.parentNode.removeChild(node);}}return elem;}jQuery.extend({htmlPrefilter:function htmlPrefilter(html){return html.replace(rxhtmlTag,"<$1></$2>");},clone:function clone(elem,dataAndEvents,deepDataAndEvents){var i,l,srcElements,destElements,clone=elem.cloneNode(true),inPage=jQuery.contains(elem.ownerDocument,elem);// Fix IE cloning issues
	if(!support.noCloneChecked&&(elem.nodeType===1||elem.nodeType===11)&&!jQuery.isXMLDoc(elem)){// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
	destElements=getAll(clone);srcElements=getAll(elem);for(i=0,l=srcElements.length;i<l;i++){fixInput(srcElements[i],destElements[i]);}}// Copy the events from the original to the clone
	if(dataAndEvents){if(deepDataAndEvents){srcElements=srcElements||getAll(elem);destElements=destElements||getAll(clone);for(i=0,l=srcElements.length;i<l;i++){cloneCopyEvent(srcElements[i],destElements[i]);}}else{cloneCopyEvent(elem,clone);}}// Preserve script evaluation history
	destElements=getAll(clone,"script");if(destElements.length>0){setGlobalEval(destElements,!inPage&&getAll(elem,"script"));}// Return the cloned set
	return clone;},cleanData:function cleanData(elems){var data,elem,type,special=jQuery.event.special,i=0;for(;(elem=elems[i])!==undefined;i++){if(acceptData(elem)){if(data=elem[dataPriv.expando]){if(data.events){for(type in data.events){if(special[type]){jQuery.event.remove(elem,type);// This is a shortcut to avoid jQuery.event.remove's overhead
	}else{jQuery.removeEvent(elem,type,data.handle);}}}// Support: Chrome <=35 - 45+
	// Assign undefined instead of using delete, see Data#remove
	elem[dataPriv.expando]=undefined;}if(elem[dataUser.expando]){// Support: Chrome <=35 - 45+
	// Assign undefined instead of using delete, see Data#remove
	elem[dataUser.expando]=undefined;}}}}});jQuery.fn.extend({detach:function detach(selector){return _remove(this,selector,true);},remove:function remove(selector){return _remove(this,selector);},text:function text(value){return access(this,function(value){return value===undefined?jQuery.text(this):this.empty().each(function(){if(this.nodeType===1||this.nodeType===11||this.nodeType===9){this.textContent=value;}});},null,value,arguments.length);},append:function append(){return domManip(this,arguments,function(elem){if(this.nodeType===1||this.nodeType===11||this.nodeType===9){var target=manipulationTarget(this,elem);target.appendChild(elem);}});},prepend:function prepend(){return domManip(this,arguments,function(elem){if(this.nodeType===1||this.nodeType===11||this.nodeType===9){var target=manipulationTarget(this,elem);target.insertBefore(elem,target.firstChild);}});},before:function before(){return domManip(this,arguments,function(elem){if(this.parentNode){this.parentNode.insertBefore(elem,this);}});},after:function after(){return domManip(this,arguments,function(elem){if(this.parentNode){this.parentNode.insertBefore(elem,this.nextSibling);}});},empty:function empty(){var elem,i=0;for(;(elem=this[i])!=null;i++){if(elem.nodeType===1){// Prevent memory leaks
	jQuery.cleanData(getAll(elem,false));// Remove any remaining nodes
	elem.textContent="";}}return this;},clone:function clone(dataAndEvents,deepDataAndEvents){dataAndEvents=dataAndEvents==null?false:dataAndEvents;deepDataAndEvents=deepDataAndEvents==null?dataAndEvents:deepDataAndEvents;return this.map(function(){return jQuery.clone(this,dataAndEvents,deepDataAndEvents);});},html:function html(value){return access(this,function(value){var elem=this[0]||{},i=0,l=this.length;if(value===undefined&&elem.nodeType===1){return elem.innerHTML;}// See if we can take a shortcut and just use innerHTML
	if(typeof value==="string"&&!rnoInnerhtml.test(value)&&!wrapMap[(rtagName.exec(value)||["",""])[1].toLowerCase()]){value=jQuery.htmlPrefilter(value);try{for(;i<l;i++){elem=this[i]||{};// Remove element nodes and prevent memory leaks
	if(elem.nodeType===1){jQuery.cleanData(getAll(elem,false));elem.innerHTML=value;}}elem=0;// If using innerHTML throws an exception, use the fallback method
	}catch(e){}}if(elem){this.empty().append(value);}},null,value,arguments.length);},replaceWith:function replaceWith(){var ignored=[];// Make the changes, replacing each non-ignored context element with the new content
	return domManip(this,arguments,function(elem){var parent=this.parentNode;if(jQuery.inArray(this,ignored)<0){jQuery.cleanData(getAll(this));if(parent){parent.replaceChild(elem,this);}}// Force callback invocation
	},ignored);}});jQuery.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(name,original){jQuery.fn[name]=function(selector){var elems,ret=[],insert=jQuery(selector),last=insert.length-1,i=0;for(;i<=last;i++){elems=i===last?this:this.clone(true);jQuery(insert[i])[original](elems);// Support: Android <=4.0 only, PhantomJS 1 only
	// .get() because push.apply(_, arraylike) throws on ancient WebKit
	push.apply(ret,elems.get());}return this.pushStack(ret);};});var rmargin=/^margin/;var rnumnonpx=new RegExp("^("+pnum+")(?!px)[a-z%]+$","i");var getStyles=function getStyles(elem){// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
	// IE throws on elements created in popups
	// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
	var view=elem.ownerDocument.defaultView;if(!view||!view.opener){view=window;}return view.getComputedStyle(elem);};(function(){// Executing both pixelPosition & boxSizingReliable tests require only one layout
	// so they're executed at the same time to save the second computation.
	function computeStyleTests(){// This is a singleton, we need to execute it only once
	if(!div){return;}div.style.cssText="box-sizing:border-box;"+"position:relative;display:block;"+"margin:auto;border:1px;padding:1px;"+"top:1%;width:50%";div.innerHTML="";documentElement.appendChild(container);var divStyle=window.getComputedStyle(div);pixelPositionVal=divStyle.top!=="1%";// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
	reliableMarginLeftVal=divStyle.marginLeft==="2px";boxSizingReliableVal=divStyle.width==="4px";// Support: Android 4.0 - 4.3 only
	// Some styles come back with percentage values, even though they shouldn't
	div.style.marginRight="50%";pixelMarginRightVal=divStyle.marginRight==="4px";documentElement.removeChild(container);// Nullify the div so it wouldn't be stored in the memory and
	// it will also be a sign that checks already performed
	div=null;}var pixelPositionVal,boxSizingReliableVal,pixelMarginRightVal,reliableMarginLeftVal,container=document.createElement("div"),div=document.createElement("div");// Finish early in limited (non-browser) environments
	if(!div.style){return;}// Support: IE <=9 - 11 only
	// Style of cloned element affects source element cloned (#8908)
	div.style.backgroundClip="content-box";div.cloneNode(true).style.backgroundClip="";support.clearCloneStyle=div.style.backgroundClip==="content-box";container.style.cssText="border:0;width:8px;height:0;top:0;left:-9999px;"+"padding:0;margin-top:1px;position:absolute";container.appendChild(div);jQuery.extend(support,{pixelPosition:function pixelPosition(){computeStyleTests();return pixelPositionVal;},boxSizingReliable:function boxSizingReliable(){computeStyleTests();return boxSizingReliableVal;},pixelMarginRight:function pixelMarginRight(){computeStyleTests();return pixelMarginRightVal;},reliableMarginLeft:function reliableMarginLeft(){computeStyleTests();return reliableMarginLeftVal;}});})();function curCSS(elem,name,computed){var width,minWidth,maxWidth,ret,style=elem.style;computed=computed||getStyles(elem);// Support: IE <=9 only
	// getPropertyValue is only needed for .css('filter') (#12537)
	if(computed){ret=computed.getPropertyValue(name)||computed[name];if(ret===""&&!jQuery.contains(elem.ownerDocument,elem)){ret=jQuery.style(elem,name);}// A tribute to the "awesome hack by Dean Edwards"
	// Android Browser returns percentage for some values,
	// but width seems to be reliably pixels.
	// This is against the CSSOM draft spec:
	// https://drafts.csswg.org/cssom/#resolved-values
	if(!support.pixelMarginRight()&&rnumnonpx.test(ret)&&rmargin.test(name)){// Remember the original values
	width=style.width;minWidth=style.minWidth;maxWidth=style.maxWidth;// Put in the new values to get a computed value out
	style.minWidth=style.maxWidth=style.width=ret;ret=computed.width;// Revert the changed values
	style.width=width;style.minWidth=minWidth;style.maxWidth=maxWidth;}}return ret!==undefined?// Support: IE <=9 - 11 only
	// IE returns zIndex value as an integer.
	ret+"":ret;}function addGetHookIf(conditionFn,hookFn){// Define the hook, we'll check on the first run if it's really needed.
	return{get:function get(){if(conditionFn()){// Hook not needed (or it's not possible to use it due
	// to missing dependency), remove it.
	delete this.get;return;}// Hook needed; redefine it so that the support test is not executed again.
	return(this.get=hookFn).apply(this,arguments);}};}var// Swappable if display is none or starts with table
	// except "table", "table-cell", or "table-caption"
	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
	rdisplayswap=/^(none|table(?!-c[ea]).+)/,cssShow={position:"absolute",visibility:"hidden",display:"block"},cssNormalTransform={letterSpacing:"0",fontWeight:"400"},cssPrefixes=["Webkit","Moz","ms"],emptyStyle=document.createElement("div").style;// Return a css property mapped to a potentially vendor prefixed property
	function vendorPropName(name){// Shortcut for names that are not vendor prefixed
	if(name in emptyStyle){return name;}// Check for vendor prefixed names
	var capName=name[0].toUpperCase()+name.slice(1),i=cssPrefixes.length;while(i--){name=cssPrefixes[i]+capName;if(name in emptyStyle){return name;}}}function setPositiveNumber(elem,value,subtract){// Any relative (+/-) values have already been
	// normalized at this point
	var matches=rcssNum.exec(value);return matches?// Guard against undefined "subtract", e.g., when used as in cssHooks
	Math.max(0,matches[2]-(subtract||0))+(matches[3]||"px"):value;}function augmentWidthOrHeight(elem,name,extra,isBorderBox,styles){var i=extra===(isBorderBox?"border":"content")?// If we already have the right measurement, avoid augmentation
	4:// Otherwise initialize for horizontal or vertical properties
	name==="width"?1:0,val=0;for(;i<4;i+=2){// Both box models exclude margin, so add it if we want it
	if(extra==="margin"){val+=jQuery.css(elem,extra+cssExpand[i],true,styles);}if(isBorderBox){// border-box includes padding, so remove it if we want content
	if(extra==="content"){val-=jQuery.css(elem,"padding"+cssExpand[i],true,styles);}// At this point, extra isn't border nor margin, so remove border
	if(extra!=="margin"){val-=jQuery.css(elem,"border"+cssExpand[i]+"Width",true,styles);}}else{// At this point, extra isn't content, so add padding
	val+=jQuery.css(elem,"padding"+cssExpand[i],true,styles);// At this point, extra isn't content nor padding, so add border
	if(extra!=="padding"){val+=jQuery.css(elem,"border"+cssExpand[i]+"Width",true,styles);}}}return val;}function getWidthOrHeight(elem,name,extra){// Start with offset property, which is equivalent to the border-box value
	var val,valueIsBorderBox=true,styles=getStyles(elem),isBorderBox=jQuery.css(elem,"boxSizing",false,styles)==="border-box";// Support: IE <=11 only
	// Running getBoundingClientRect on a disconnected node
	// in IE throws an error.
	if(elem.getClientRects().length){val=elem.getBoundingClientRect()[name];}// Some non-html elements return undefined for offsetWidth, so check for null/undefined
	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
	if(val<=0||val==null){// Fall back to computed then uncomputed css if necessary
	val=curCSS(elem,name,styles);if(val<0||val==null){val=elem.style[name];}// Computed unit is not pixels. Stop here and return.
	if(rnumnonpx.test(val)){return val;}// Check for style in case a browser which returns unreliable values
	// for getComputedStyle silently falls back to the reliable elem.style
	valueIsBorderBox=isBorderBox&&(support.boxSizingReliable()||val===elem.style[name]);// Normalize "", auto, and prepare for extra
	val=parseFloat(val)||0;}// Use the active box-sizing model to add/subtract irrelevant styles
	return val+augmentWidthOrHeight(elem,name,extra||(isBorderBox?"border":"content"),valueIsBorderBox,styles)+"px";}jQuery.extend({// Add in style property hooks for overriding the default
	// behavior of getting and setting a style property
	cssHooks:{opacity:{get:function get(elem,computed){if(computed){// We should always get a number back from opacity
	var ret=curCSS(elem,"opacity");return ret===""?"1":ret;}}}},// Don't automatically add "px" to these possibly-unitless properties
	cssNumber:{"animationIterationCount":true,"columnCount":true,"fillOpacity":true,"flexGrow":true,"flexShrink":true,"fontWeight":true,"lineHeight":true,"opacity":true,"order":true,"orphans":true,"widows":true,"zIndex":true,"zoom":true},// Add in properties whose names you wish to fix before
	// setting or getting the value
	cssProps:{"float":"cssFloat"},// Get and set the style property on a DOM Node
	style:function style(elem,name,value,extra){// Don't set styles on text and comment nodes
	if(!elem||elem.nodeType===3||elem.nodeType===8||!elem.style){return;}// Make sure that we're working with the right name
	var ret,type,hooks,origName=jQuery.camelCase(name),style=elem.style;name=jQuery.cssProps[origName]||(jQuery.cssProps[origName]=vendorPropName(origName)||origName);// Gets hook for the prefixed version, then unprefixed version
	hooks=jQuery.cssHooks[name]||jQuery.cssHooks[origName];// Check if we're setting a value
	if(value!==undefined){type=typeof value==="undefined"?"undefined":_typeof(value);// Convert "+=" or "-=" to relative numbers (#7345)
	if(type==="string"&&(ret=rcssNum.exec(value))&&ret[1]){value=adjustCSS(elem,name,ret);// Fixes bug #9237
	type="number";}// Make sure that null and NaN values aren't set (#7116)
	if(value==null||value!==value){return;}// If a number was passed in, add the unit (except for certain CSS properties)
	if(type==="number"){value+=ret&&ret[3]||(jQuery.cssNumber[origName]?"":"px");}// background-* props affect original clone's values
	if(!support.clearCloneStyle&&value===""&&name.indexOf("background")===0){style[name]="inherit";}// If a hook was provided, use that value, otherwise just set the specified value
	if(!hooks||!("set"in hooks)||(value=hooks.set(elem,value,extra))!==undefined){style[name]=value;}}else{// If a hook was provided get the non-computed value from there
	if(hooks&&"get"in hooks&&(ret=hooks.get(elem,false,extra))!==undefined){return ret;}// Otherwise just get the value from the style object
	return style[name];}},css:function css(elem,name,extra,styles){var val,num,hooks,origName=jQuery.camelCase(name);// Make sure that we're working with the right name
	name=jQuery.cssProps[origName]||(jQuery.cssProps[origName]=vendorPropName(origName)||origName);// Try prefixed name followed by the unprefixed name
	hooks=jQuery.cssHooks[name]||jQuery.cssHooks[origName];// If a hook was provided get the computed value from there
	if(hooks&&"get"in hooks){val=hooks.get(elem,true,extra);}// Otherwise, if a way to get the computed value exists, use that
	if(val===undefined){val=curCSS(elem,name,styles);}// Convert "normal" to computed value
	if(val==="normal"&&name in cssNormalTransform){val=cssNormalTransform[name];}// Make numeric if forced or a qualifier was provided and val looks numeric
	if(extra===""||extra){num=parseFloat(val);return extra===true||isFinite(num)?num||0:val;}return val;}});jQuery.each(["height","width"],function(i,name){jQuery.cssHooks[name]={get:function get(elem,computed,extra){if(computed){// Certain elements can have dimension info if we invisibly show them
	// but it must have a current display style that would benefit
	return rdisplayswap.test(jQuery.css(elem,"display"))&&(// Support: Safari 8+
	// Table columns in Safari have non-zero offsetWidth & zero
	// getBoundingClientRect().width unless display is changed.
	// Support: IE <=11 only
	// Running getBoundingClientRect on a disconnected node
	// in IE throws an error.
	!elem.getClientRects().length||!elem.getBoundingClientRect().width)?swap(elem,cssShow,function(){return getWidthOrHeight(elem,name,extra);}):getWidthOrHeight(elem,name,extra);}},set:function set(elem,value,extra){var matches,styles=extra&&getStyles(elem),subtract=extra&&augmentWidthOrHeight(elem,name,extra,jQuery.css(elem,"boxSizing",false,styles)==="border-box",styles);// Convert to pixels if value adjustment is needed
	if(subtract&&(matches=rcssNum.exec(value))&&(matches[3]||"px")!=="px"){elem.style[name]=value;value=jQuery.css(elem,name);}return setPositiveNumber(elem,value,subtract);}};});jQuery.cssHooks.marginLeft=addGetHookIf(support.reliableMarginLeft,function(elem,computed){if(computed){return(parseFloat(curCSS(elem,"marginLeft"))||elem.getBoundingClientRect().left-swap(elem,{marginLeft:0},function(){return elem.getBoundingClientRect().left;}))+"px";}});// These hooks are used by animate to expand properties
	jQuery.each({margin:"",padding:"",border:"Width"},function(prefix,suffix){jQuery.cssHooks[prefix+suffix]={expand:function expand(value){var i=0,expanded={},// Assumes a single number if not a string
	parts=typeof value==="string"?value.split(" "):[value];for(;i<4;i++){expanded[prefix+cssExpand[i]+suffix]=parts[i]||parts[i-2]||parts[0];}return expanded;}};if(!rmargin.test(prefix)){jQuery.cssHooks[prefix+suffix].set=setPositiveNumber;}});jQuery.fn.extend({css:function css(name,value){return access(this,function(elem,name,value){var styles,len,map={},i=0;if(jQuery.isArray(name)){styles=getStyles(elem);len=name.length;for(;i<len;i++){map[name[i]]=jQuery.css(elem,name[i],false,styles);}return map;}return value!==undefined?jQuery.style(elem,name,value):jQuery.css(elem,name);},name,value,arguments.length>1);}});function Tween(elem,options,prop,end,easing){return new Tween.prototype.init(elem,options,prop,end,easing);}jQuery.Tween=Tween;Tween.prototype={constructor:Tween,init:function init(elem,options,prop,end,easing,unit){this.elem=elem;this.prop=prop;this.easing=easing||jQuery.easing._default;this.options=options;this.start=this.now=this.cur();this.end=end;this.unit=unit||(jQuery.cssNumber[prop]?"":"px");},cur:function cur(){var hooks=Tween.propHooks[this.prop];return hooks&&hooks.get?hooks.get(this):Tween.propHooks._default.get(this);},run:function run(percent){var eased,hooks=Tween.propHooks[this.prop];if(this.options.duration){this.pos=eased=jQuery.easing[this.easing](percent,this.options.duration*percent,0,1,this.options.duration);}else{this.pos=eased=percent;}this.now=(this.end-this.start)*eased+this.start;if(this.options.step){this.options.step.call(this.elem,this.now,this);}if(hooks&&hooks.set){hooks.set(this);}else{Tween.propHooks._default.set(this);}return this;}};Tween.prototype.init.prototype=Tween.prototype;Tween.propHooks={_default:{get:function get(tween){var result;// Use a property on the element directly when it is not a DOM element,
	// or when there is no matching style property that exists.
	if(tween.elem.nodeType!==1||tween.elem[tween.prop]!=null&&tween.elem.style[tween.prop]==null){return tween.elem[tween.prop];}// Passing an empty string as a 3rd parameter to .css will automatically
	// attempt a parseFloat and fallback to a string if the parse fails.
	// Simple values such as "10px" are parsed to Float;
	// complex values such as "rotate(1rad)" are returned as-is.
	result=jQuery.css(tween.elem,tween.prop,"");// Empty strings, null, undefined and "auto" are converted to 0.
	return!result||result==="auto"?0:result;},set:function set(tween){// Use step hook for back compat.
	// Use cssHook if its there.
	// Use .style if available and use plain properties where available.
	if(jQuery.fx.step[tween.prop]){jQuery.fx.step[tween.prop](tween);}else if(tween.elem.nodeType===1&&(tween.elem.style[jQuery.cssProps[tween.prop]]!=null||jQuery.cssHooks[tween.prop])){jQuery.style(tween.elem,tween.prop,tween.now+tween.unit);}else{tween.elem[tween.prop]=tween.now;}}}};// Support: IE <=9 only
	// Panic based approach to setting things on disconnected nodes
	Tween.propHooks.scrollTop=Tween.propHooks.scrollLeft={set:function set(tween){if(tween.elem.nodeType&&tween.elem.parentNode){tween.elem[tween.prop]=tween.now;}}};jQuery.easing={linear:function linear(p){return p;},swing:function swing(p){return 0.5-Math.cos(p*Math.PI)/2;},_default:"swing"};jQuery.fx=Tween.prototype.init;// Back compat <1.8 extension point
	jQuery.fx.step={};var fxNow,timerId,rfxtypes=/^(?:toggle|show|hide)$/,rrun=/queueHooks$/;function raf(){if(timerId){window.requestAnimationFrame(raf);jQuery.fx.tick();}}// Animations created synchronously will run synchronously
	function createFxNow(){window.setTimeout(function(){fxNow=undefined;});return fxNow=jQuery.now();}// Generate parameters to create a standard animation
	function genFx(type,includeWidth){var which,i=0,attrs={height:type};// If we include width, step value is 1 to do all cssExpand values,
	// otherwise step value is 2 to skip over Left and Right
	includeWidth=includeWidth?1:0;for(;i<4;i+=2-includeWidth){which=cssExpand[i];attrs["margin"+which]=attrs["padding"+which]=type;}if(includeWidth){attrs.opacity=attrs.width=type;}return attrs;}function createTween(value,prop,animation){var tween,collection=(Animation.tweeners[prop]||[]).concat(Animation.tweeners["*"]),index=0,length=collection.length;for(;index<length;index++){if(tween=collection[index].call(animation,prop,value)){// We're done with this property
	return tween;}}}function defaultPrefilter(elem,props,opts){/* jshint validthis: true */var prop,value,toggle,hooks,oldfire,propTween,restoreDisplay,display,isBox="width"in props||"height"in props,anim=this,orig={},style=elem.style,hidden=elem.nodeType&&isHiddenWithinTree(elem),dataShow=dataPriv.get(elem,"fxshow");// Queue-skipping animations hijack the fx hooks
	if(!opts.queue){hooks=jQuery._queueHooks(elem,"fx");if(hooks.unqueued==null){hooks.unqueued=0;oldfire=hooks.empty.fire;hooks.empty.fire=function(){if(!hooks.unqueued){oldfire();}};}hooks.unqueued++;anim.always(function(){// Ensure the complete handler is called before this completes
	anim.always(function(){hooks.unqueued--;if(!jQuery.queue(elem,"fx").length){hooks.empty.fire();}});});}// Detect show/hide animations
	for(prop in props){value=props[prop];if(rfxtypes.test(value)){delete props[prop];toggle=toggle||value==="toggle";if(value===(hidden?"hide":"show")){// Pretend to be hidden if this is a "show" and
	// there is still data from a stopped show/hide
	if(value==="show"&&dataShow&&dataShow[prop]!==undefined){hidden=true;// Ignore all other no-op show/hide data
	}else{continue;}}orig[prop]=dataShow&&dataShow[prop]||jQuery.style(elem,prop);}}// Bail out if this is a no-op like .hide().hide()
	propTween=!jQuery.isEmptyObject(props);if(!propTween&&jQuery.isEmptyObject(orig)){return;}// Restrict "overflow" and "display" styles during box animations
	if(isBox&&elem.nodeType===1){// Support: IE <=9 - 11, Edge 12 - 13
	// Record all 3 overflow attributes because IE does not infer the shorthand
	// from identically-valued overflowX and overflowY
	opts.overflow=[style.overflow,style.overflowX,style.overflowY];// Identify a display type, preferring old show/hide data over the CSS cascade
	restoreDisplay=dataShow&&dataShow.display;if(restoreDisplay==null){restoreDisplay=dataPriv.get(elem,"display");}display=jQuery.css(elem,"display");if(display==="none"){if(restoreDisplay){display=restoreDisplay;}else{// Get nonempty value(s) by temporarily forcing visibility
	showHide([elem],true);restoreDisplay=elem.style.display||restoreDisplay;display=jQuery.css(elem,"display");showHide([elem]);}}// Animate inline elements as inline-block
	if(display==="inline"||display==="inline-block"&&restoreDisplay!=null){if(jQuery.css(elem,"float")==="none"){// Restore the original display value at the end of pure show/hide animations
	if(!propTween){anim.done(function(){style.display=restoreDisplay;});if(restoreDisplay==null){display=style.display;restoreDisplay=display==="none"?"":display;}}style.display="inline-block";}}}if(opts.overflow){style.overflow="hidden";anim.always(function(){style.overflow=opts.overflow[0];style.overflowX=opts.overflow[1];style.overflowY=opts.overflow[2];});}// Implement show/hide animations
	propTween=false;for(prop in orig){// General show/hide setup for this element animation
	if(!propTween){if(dataShow){if("hidden"in dataShow){hidden=dataShow.hidden;}}else{dataShow=dataPriv.access(elem,"fxshow",{display:restoreDisplay});}// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
	if(toggle){dataShow.hidden=!hidden;}// Show elements before animating them
	if(hidden){showHide([elem],true);}/* jshint -W083 */anim.done(function(){// The final step of a "hide" animation is actually hiding the element
	if(!hidden){showHide([elem]);}dataPriv.remove(elem,"fxshow");for(prop in orig){jQuery.style(elem,prop,orig[prop]);}});}// Per-property setup
	propTween=createTween(hidden?dataShow[prop]:0,prop,anim);if(!(prop in dataShow)){dataShow[prop]=propTween.start;if(hidden){propTween.end=propTween.start;propTween.start=0;}}}}function propFilter(props,specialEasing){var index,name,easing,value,hooks;// camelCase, specialEasing and expand cssHook pass
	for(index in props){name=jQuery.camelCase(index);easing=specialEasing[name];value=props[index];if(jQuery.isArray(value)){easing=value[1];value=props[index]=value[0];}if(index!==name){props[name]=value;delete props[index];}hooks=jQuery.cssHooks[name];if(hooks&&"expand"in hooks){value=hooks.expand(value);delete props[name];// Not quite $.extend, this won't overwrite existing keys.
	// Reusing 'index' because we have the correct "name"
	for(index in value){if(!(index in props)){props[index]=value[index];specialEasing[index]=easing;}}}else{specialEasing[name]=easing;}}}function Animation(elem,properties,options){var result,stopped,index=0,length=Animation.prefilters.length,deferred=jQuery.Deferred().always(function(){// Don't match elem in the :animated selector
	delete tick.elem;}),tick=function tick(){if(stopped){return false;}var currentTime=fxNow||createFxNow(),remaining=Math.max(0,animation.startTime+animation.duration-currentTime),// Support: Android 2.3 only
	// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
	temp=remaining/animation.duration||0,percent=1-temp,index=0,length=animation.tweens.length;for(;index<length;index++){animation.tweens[index].run(percent);}deferred.notifyWith(elem,[animation,percent,remaining]);if(percent<1&&length){return remaining;}else{deferred.resolveWith(elem,[animation]);return false;}},animation=deferred.promise({elem:elem,props:jQuery.extend({},properties),opts:jQuery.extend(true,{specialEasing:{},easing:jQuery.easing._default},options),originalProperties:properties,originalOptions:options,startTime:fxNow||createFxNow(),duration:options.duration,tweens:[],createTween:function createTween(prop,end){var tween=jQuery.Tween(elem,animation.opts,prop,end,animation.opts.specialEasing[prop]||animation.opts.easing);animation.tweens.push(tween);return tween;},stop:function stop(gotoEnd){var index=0,// If we are going to the end, we want to run all the tweens
	// otherwise we skip this part
	length=gotoEnd?animation.tweens.length:0;if(stopped){return this;}stopped=true;for(;index<length;index++){animation.tweens[index].run(1);}// Resolve when we played the last frame; otherwise, reject
	if(gotoEnd){deferred.notifyWith(elem,[animation,1,0]);deferred.resolveWith(elem,[animation,gotoEnd]);}else{deferred.rejectWith(elem,[animation,gotoEnd]);}return this;}}),props=animation.props;propFilter(props,animation.opts.specialEasing);for(;index<length;index++){result=Animation.prefilters[index].call(animation,elem,props,animation.opts);if(result){if(jQuery.isFunction(result.stop)){jQuery._queueHooks(animation.elem,animation.opts.queue).stop=jQuery.proxy(result.stop,result);}return result;}}jQuery.map(props,createTween,animation);if(jQuery.isFunction(animation.opts.start)){animation.opts.start.call(elem,animation);}jQuery.fx.timer(jQuery.extend(tick,{elem:elem,anim:animation,queue:animation.opts.queue}));// attach callbacks from options
	return animation.progress(animation.opts.progress).done(animation.opts.done,animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);}jQuery.Animation=jQuery.extend(Animation,{tweeners:{"*":[function(prop,value){var tween=this.createTween(prop,value);adjustCSS(tween.elem,prop,rcssNum.exec(value),tween);return tween;}]},tweener:function tweener(props,callback){if(jQuery.isFunction(props)){callback=props;props=["*"];}else{props=props.match(rnotwhite);}var prop,index=0,length=props.length;for(;index<length;index++){prop=props[index];Animation.tweeners[prop]=Animation.tweeners[prop]||[];Animation.tweeners[prop].unshift(callback);}},prefilters:[defaultPrefilter],prefilter:function prefilter(callback,prepend){if(prepend){Animation.prefilters.unshift(callback);}else{Animation.prefilters.push(callback);}}});jQuery.speed=function(speed,easing,fn){var opt=speed&&(typeof speed==="undefined"?"undefined":_typeof(speed))==="object"?jQuery.extend({},speed):{complete:fn||!fn&&easing||jQuery.isFunction(speed)&&speed,duration:speed,easing:fn&&easing||easing&&!jQuery.isFunction(easing)&&easing};// Go to the end state if fx are off or if document is hidden
	if(jQuery.fx.off||document.hidden){opt.duration=0;}else{opt.duration=typeof opt.duration==="number"?opt.duration:opt.duration in jQuery.fx.speeds?jQuery.fx.speeds[opt.duration]:jQuery.fx.speeds._default;}// Normalize opt.queue - true/undefined/null -> "fx"
	if(opt.queue==null||opt.queue===true){opt.queue="fx";}// Queueing
	opt.old=opt.complete;opt.complete=function(){if(jQuery.isFunction(opt.old)){opt.old.call(this);}if(opt.queue){jQuery.dequeue(this,opt.queue);}};return opt;};jQuery.fn.extend({fadeTo:function fadeTo(speed,to,easing,callback){// Show any hidden elements after setting opacity to 0
	return this.filter(isHiddenWithinTree).css("opacity",0).show()// Animate to the value specified
	.end().animate({opacity:to},speed,easing,callback);},animate:function animate(prop,speed,easing,callback){var empty=jQuery.isEmptyObject(prop),optall=jQuery.speed(speed,easing,callback),doAnimation=function doAnimation(){// Operate on a copy of prop so per-property easing won't be lost
	var anim=Animation(this,jQuery.extend({},prop),optall);// Empty animations, or finishing resolves immediately
	if(empty||dataPriv.get(this,"finish")){anim.stop(true);}};doAnimation.finish=doAnimation;return empty||optall.queue===false?this.each(doAnimation):this.queue(optall.queue,doAnimation);},stop:function stop(type,clearQueue,gotoEnd){var stopQueue=function stopQueue(hooks){var stop=hooks.stop;delete hooks.stop;stop(gotoEnd);};if(typeof type!=="string"){gotoEnd=clearQueue;clearQueue=type;type=undefined;}if(clearQueue&&type!==false){this.queue(type||"fx",[]);}return this.each(function(){var dequeue=true,index=type!=null&&type+"queueHooks",timers=jQuery.timers,data=dataPriv.get(this);if(index){if(data[index]&&data[index].stop){stopQueue(data[index]);}}else{for(index in data){if(data[index]&&data[index].stop&&rrun.test(index)){stopQueue(data[index]);}}}for(index=timers.length;index--;){if(timers[index].elem===this&&(type==null||timers[index].queue===type)){timers[index].anim.stop(gotoEnd);dequeue=false;timers.splice(index,1);}}// Start the next in the queue if the last step wasn't forced.
	// Timers currently will call their complete callbacks, which
	// will dequeue but only if they were gotoEnd.
	if(dequeue||!gotoEnd){jQuery.dequeue(this,type);}});},finish:function finish(type){if(type!==false){type=type||"fx";}return this.each(function(){var index,data=dataPriv.get(this),queue=data[type+"queue"],hooks=data[type+"queueHooks"],timers=jQuery.timers,length=queue?queue.length:0;// Enable finishing flag on private data
	data.finish=true;// Empty the queue first
	jQuery.queue(this,type,[]);if(hooks&&hooks.stop){hooks.stop.call(this,true);}// Look for any active animations, and finish them
	for(index=timers.length;index--;){if(timers[index].elem===this&&timers[index].queue===type){timers[index].anim.stop(true);timers.splice(index,1);}}// Look for any animations in the old queue and finish them
	for(index=0;index<length;index++){if(queue[index]&&queue[index].finish){queue[index].finish.call(this);}}// Turn off finishing flag
	delete data.finish;});}});jQuery.each(["toggle","show","hide"],function(i,name){var cssFn=jQuery.fn[name];jQuery.fn[name]=function(speed,easing,callback){return speed==null||typeof speed==="boolean"?cssFn.apply(this,arguments):this.animate(genFx(name,true),speed,easing,callback);};});// Generate shortcuts for custom animations
	jQuery.each({slideDown:genFx("show"),slideUp:genFx("hide"),slideToggle:genFx("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(name,props){jQuery.fn[name]=function(speed,easing,callback){return this.animate(props,speed,easing,callback);};});jQuery.timers=[];jQuery.fx.tick=function(){var timer,i=0,timers=jQuery.timers;fxNow=jQuery.now();for(;i<timers.length;i++){timer=timers[i];// Checks the timer has not already been removed
	if(!timer()&&timers[i]===timer){timers.splice(i--,1);}}if(!timers.length){jQuery.fx.stop();}fxNow=undefined;};jQuery.fx.timer=function(timer){jQuery.timers.push(timer);if(timer()){jQuery.fx.start();}else{jQuery.timers.pop();}};jQuery.fx.interval=13;jQuery.fx.start=function(){if(!timerId){timerId=window.requestAnimationFrame?window.requestAnimationFrame(raf):window.setInterval(jQuery.fx.tick,jQuery.fx.interval);}};jQuery.fx.stop=function(){if(window.cancelAnimationFrame){window.cancelAnimationFrame(timerId);}else{window.clearInterval(timerId);}timerId=null;};jQuery.fx.speeds={slow:600,fast:200,// Default speed
	_default:400};// Based off of the plugin by Clint Helfers, with permission.
	// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
	jQuery.fn.delay=function(time,type){time=jQuery.fx?jQuery.fx.speeds[time]||time:time;type=type||"fx";return this.queue(type,function(next,hooks){var timeout=window.setTimeout(next,time);hooks.stop=function(){window.clearTimeout(timeout);};});};(function(){var input=document.createElement("input"),select=document.createElement("select"),opt=select.appendChild(document.createElement("option"));input.type="checkbox";// Support: Android <=4.3 only
	// Default value for a checkbox should be "on"
	support.checkOn=input.value!=="";// Support: IE <=11 only
	// Must access selectedIndex to make default options select
	support.optSelected=opt.selected;// Support: IE <=11 only
	// An input loses its value after becoming a radio
	input=document.createElement("input");input.value="t";input.type="radio";support.radioValue=input.value==="t";})();var boolHook,attrHandle=jQuery.expr.attrHandle;jQuery.fn.extend({attr:function attr(name,value){return access(this,jQuery.attr,name,value,arguments.length>1);},removeAttr:function removeAttr(name){return this.each(function(){jQuery.removeAttr(this,name);});}});jQuery.extend({attr:function attr(elem,name,value){var ret,hooks,nType=elem.nodeType;// Don't get/set attributes on text, comment and attribute nodes
	if(nType===3||nType===8||nType===2){return;}// Fallback to prop when attributes are not supported
	if(typeof elem.getAttribute==="undefined"){return jQuery.prop(elem,name,value);}// Attribute hooks are determined by the lowercase version
	// Grab necessary hook if one is defined
	if(nType!==1||!jQuery.isXMLDoc(elem)){hooks=jQuery.attrHooks[name.toLowerCase()]||(jQuery.expr.match.bool.test(name)?boolHook:undefined);}if(value!==undefined){if(value===null){jQuery.removeAttr(elem,name);return;}if(hooks&&"set"in hooks&&(ret=hooks.set(elem,value,name))!==undefined){return ret;}elem.setAttribute(name,value+"");return value;}if(hooks&&"get"in hooks&&(ret=hooks.get(elem,name))!==null){return ret;}ret=jQuery.find.attr(elem,name);// Non-existent attributes return null, we normalize to undefined
	return ret==null?undefined:ret;},attrHooks:{type:{set:function set(elem,value){if(!support.radioValue&&value==="radio"&&jQuery.nodeName(elem,"input")){var val=elem.value;elem.setAttribute("type",value);if(val){elem.value=val;}return value;}}}},removeAttr:function removeAttr(elem,value){var name,i=0,attrNames=value&&value.match(rnotwhite);if(attrNames&&elem.nodeType===1){while(name=attrNames[i++]){elem.removeAttribute(name);}}}});// Hooks for boolean attributes
	boolHook={set:function set(elem,value,name){if(value===false){// Remove boolean attributes when set to false
	jQuery.removeAttr(elem,name);}else{elem.setAttribute(name,name);}return name;}};jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g),function(i,name){var getter=attrHandle[name]||jQuery.find.attr;attrHandle[name]=function(elem,name,isXML){var ret,handle,lowercaseName=name.toLowerCase();if(!isXML){// Avoid an infinite loop by temporarily removing this function from the getter
	handle=attrHandle[lowercaseName];attrHandle[lowercaseName]=ret;ret=getter(elem,name,isXML)!=null?lowercaseName:null;attrHandle[lowercaseName]=handle;}return ret;};});var rfocusable=/^(?:input|select|textarea|button)$/i,rclickable=/^(?:a|area)$/i;jQuery.fn.extend({prop:function prop(name,value){return access(this,jQuery.prop,name,value,arguments.length>1);},removeProp:function removeProp(name){return this.each(function(){delete this[jQuery.propFix[name]||name];});}});jQuery.extend({prop:function prop(elem,name,value){var ret,hooks,nType=elem.nodeType;// Don't get/set properties on text, comment and attribute nodes
	if(nType===3||nType===8||nType===2){return;}if(nType!==1||!jQuery.isXMLDoc(elem)){// Fix name and attach hooks
	name=jQuery.propFix[name]||name;hooks=jQuery.propHooks[name];}if(value!==undefined){if(hooks&&"set"in hooks&&(ret=hooks.set(elem,value,name))!==undefined){return ret;}return elem[name]=value;}if(hooks&&"get"in hooks&&(ret=hooks.get(elem,name))!==null){return ret;}return elem[name];},propHooks:{tabIndex:{get:function get(elem){// Support: IE <=9 - 11 only
	// elem.tabIndex doesn't always return the
	// correct value when it hasn't been explicitly set
	// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
	// Use proper attribute retrieval(#12072)
	var tabindex=jQuery.find.attr(elem,"tabindex");return tabindex?parseInt(tabindex,10):rfocusable.test(elem.nodeName)||rclickable.test(elem.nodeName)&&elem.href?0:-1;}}},propFix:{"for":"htmlFor","class":"className"}});// Support: IE <=11 only
	// Accessing the selectedIndex property
	// forces the browser to respect setting selected
	// on the option
	// The getter ensures a default option is selected
	// when in an optgroup
	if(!support.optSelected){jQuery.propHooks.selected={get:function get(elem){var parent=elem.parentNode;if(parent&&parent.parentNode){parent.parentNode.selectedIndex;}return null;},set:function set(elem){var parent=elem.parentNode;if(parent){parent.selectedIndex;if(parent.parentNode){parent.parentNode.selectedIndex;}}}};}jQuery.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){jQuery.propFix[this.toLowerCase()]=this;});var rclass=/[\t\r\n\f]/g;function getClass(elem){return elem.getAttribute&&elem.getAttribute("class")||"";}jQuery.fn.extend({addClass:function addClass(value){var classes,elem,cur,curValue,clazz,j,finalValue,i=0;if(jQuery.isFunction(value)){return this.each(function(j){jQuery(this).addClass(value.call(this,j,getClass(this)));});}if(typeof value==="string"&&value){classes=value.match(rnotwhite)||[];while(elem=this[i++]){curValue=getClass(elem);cur=elem.nodeType===1&&(" "+curValue+" ").replace(rclass," ");if(cur){j=0;while(clazz=classes[j++]){if(cur.indexOf(" "+clazz+" ")<0){cur+=clazz+" ";}}// Only assign if different to avoid unneeded rendering.
	finalValue=jQuery.trim(cur);if(curValue!==finalValue){elem.setAttribute("class",finalValue);}}}}return this;},removeClass:function removeClass(value){var classes,elem,cur,curValue,clazz,j,finalValue,i=0;if(jQuery.isFunction(value)){return this.each(function(j){jQuery(this).removeClass(value.call(this,j,getClass(this)));});}if(!arguments.length){return this.attr("class","");}if(typeof value==="string"&&value){classes=value.match(rnotwhite)||[];while(elem=this[i++]){curValue=getClass(elem);// This expression is here for better compressibility (see addClass)
	cur=elem.nodeType===1&&(" "+curValue+" ").replace(rclass," ");if(cur){j=0;while(clazz=classes[j++]){// Remove *all* instances
	while(cur.indexOf(" "+clazz+" ")>-1){cur=cur.replace(" "+clazz+" "," ");}}// Only assign if different to avoid unneeded rendering.
	finalValue=jQuery.trim(cur);if(curValue!==finalValue){elem.setAttribute("class",finalValue);}}}}return this;},toggleClass:function toggleClass(value,stateVal){var type=typeof value==="undefined"?"undefined":_typeof(value);if(typeof stateVal==="boolean"&&type==="string"){return stateVal?this.addClass(value):this.removeClass(value);}if(jQuery.isFunction(value)){return this.each(function(i){jQuery(this).toggleClass(value.call(this,i,getClass(this),stateVal),stateVal);});}return this.each(function(){var className,i,self,classNames;if(type==="string"){// Toggle individual class names
	i=0;self=jQuery(this);classNames=value.match(rnotwhite)||[];while(className=classNames[i++]){// Check each className given, space separated list
	if(self.hasClass(className)){self.removeClass(className);}else{self.addClass(className);}}// Toggle whole class name
	}else if(value===undefined||type==="boolean"){className=getClass(this);if(className){// Store className if set
	dataPriv.set(this,"__className__",className);}// If the element has a class name or if we're passed `false`,
	// then remove the whole classname (if there was one, the above saved it).
	// Otherwise bring back whatever was previously saved (if anything),
	// falling back to the empty string if nothing was stored.
	if(this.setAttribute){this.setAttribute("class",className||value===false?"":dataPriv.get(this,"__className__")||"");}}});},hasClass:function hasClass(selector){var className,elem,i=0;className=" "+selector+" ";while(elem=this[i++]){if(elem.nodeType===1&&(" "+getClass(elem)+" ").replace(rclass," ").indexOf(className)>-1){return true;}}return false;}});var rreturn=/\r/g,rspaces=/[\x20\t\r\n\f]+/g;jQuery.fn.extend({val:function val(value){var hooks,ret,isFunction,elem=this[0];if(!arguments.length){if(elem){hooks=jQuery.valHooks[elem.type]||jQuery.valHooks[elem.nodeName.toLowerCase()];if(hooks&&"get"in hooks&&(ret=hooks.get(elem,"value"))!==undefined){return ret;}ret=elem.value;return typeof ret==="string"?// Handle most common string cases
	ret.replace(rreturn,""):// Handle cases where value is null/undef or number
	ret==null?"":ret;}return;}isFunction=jQuery.isFunction(value);return this.each(function(i){var val;if(this.nodeType!==1){return;}if(isFunction){val=value.call(this,i,jQuery(this).val());}else{val=value;}// Treat null/undefined as ""; convert numbers to string
	if(val==null){val="";}else if(typeof val==="number"){val+="";}else if(jQuery.isArray(val)){val=jQuery.map(val,function(value){return value==null?"":value+"";});}hooks=jQuery.valHooks[this.type]||jQuery.valHooks[this.nodeName.toLowerCase()];// If set returns undefined, fall back to normal setting
	if(!hooks||!("set"in hooks)||hooks.set(this,val,"value")===undefined){this.value=val;}});}});jQuery.extend({valHooks:{option:{get:function get(elem){var val=jQuery.find.attr(elem,"value");return val!=null?val:// Support: IE <=10 - 11 only
	// option.text throws exceptions (#14686, #14858)
	// Strip and collapse whitespace
	// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
	jQuery.trim(jQuery.text(elem)).replace(rspaces," ");}},select:{get:function get(elem){var value,option,options=elem.options,index=elem.selectedIndex,one=elem.type==="select-one",values=one?null:[],max=one?index+1:options.length,i=index<0?max:one?index:0;// Loop through all the selected options
	for(;i<max;i++){option=options[i];// Support: IE <=9 only
	// IE8-9 doesn't update selected after form reset (#2551)
	if((option.selected||i===index)&&// Don't return options that are disabled or in a disabled optgroup
	!option.disabled&&(!option.parentNode.disabled||!jQuery.nodeName(option.parentNode,"optgroup"))){// Get the specific value for the option
	value=jQuery(option).val();// We don't need an array for one selects
	if(one){return value;}// Multi-Selects return an array
	values.push(value);}}return values;},set:function set(elem,value){var optionSet,option,options=elem.options,values=jQuery.makeArray(value),i=options.length;while(i--){option=options[i];if(option.selected=jQuery.inArray(jQuery.valHooks.option.get(option),values)>-1){optionSet=true;}}// Force browsers to behave consistently when non-matching value is set
	if(!optionSet){elem.selectedIndex=-1;}return values;}}}});// Radios and checkboxes getter/setter
	jQuery.each(["radio","checkbox"],function(){jQuery.valHooks[this]={set:function set(elem,value){if(jQuery.isArray(value)){return elem.checked=jQuery.inArray(jQuery(elem).val(),value)>-1;}}};if(!support.checkOn){jQuery.valHooks[this].get=function(elem){return elem.getAttribute("value")===null?"on":elem.value;};}});// Return jQuery for attributes-only inclusion
	var rfocusMorph=/^(?:focusinfocus|focusoutblur)$/;jQuery.extend(jQuery.event,{trigger:function trigger(event,data,elem,onlyHandlers){var i,cur,tmp,bubbleType,ontype,handle,special,eventPath=[elem||document],type=hasOwn.call(event,"type")?event.type:event,namespaces=hasOwn.call(event,"namespace")?event.namespace.split("."):[];cur=tmp=elem=elem||document;// Don't do events on text and comment nodes
	if(elem.nodeType===3||elem.nodeType===8){return;}// focus/blur morphs to focusin/out; ensure we're not firing them right now
	if(rfocusMorph.test(type+jQuery.event.triggered)){return;}if(type.indexOf(".")>-1){// Namespaced trigger; create a regexp to match event type in handle()
	namespaces=type.split(".");type=namespaces.shift();namespaces.sort();}ontype=type.indexOf(":")<0&&"on"+type;// Caller can pass in a jQuery.Event object, Object, or just an event type string
	event=event[jQuery.expando]?event:new jQuery.Event(type,(typeof event==="undefined"?"undefined":_typeof(event))==="object"&&event);// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
	event.isTrigger=onlyHandlers?2:3;event.namespace=namespaces.join(".");event.rnamespace=event.namespace?new RegExp("(^|\\.)"+namespaces.join("\\.(?:.*\\.|)")+"(\\.|$)"):null;// Clean up the event in case it is being reused
	event.result=undefined;if(!event.target){event.target=elem;}// Clone any incoming data and prepend the event, creating the handler arg list
	data=data==null?[event]:jQuery.makeArray(data,[event]);// Allow special events to draw outside the lines
	special=jQuery.event.special[type]||{};if(!onlyHandlers&&special.trigger&&special.trigger.apply(elem,data)===false){return;}// Determine event propagation path in advance, per W3C events spec (#9951)
	// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
	if(!onlyHandlers&&!special.noBubble&&!jQuery.isWindow(elem)){bubbleType=special.delegateType||type;if(!rfocusMorph.test(bubbleType+type)){cur=cur.parentNode;}for(;cur;cur=cur.parentNode){eventPath.push(cur);tmp=cur;}// Only add window if we got to document (e.g., not plain obj or detached DOM)
	if(tmp===(elem.ownerDocument||document)){eventPath.push(tmp.defaultView||tmp.parentWindow||window);}}// Fire handlers on the event path
	i=0;while((cur=eventPath[i++])&&!event.isPropagationStopped()){event.type=i>1?bubbleType:special.bindType||type;// jQuery handler
	handle=(dataPriv.get(cur,"events")||{})[event.type]&&dataPriv.get(cur,"handle");if(handle){handle.apply(cur,data);}// Native handler
	handle=ontype&&cur[ontype];if(handle&&handle.apply&&acceptData(cur)){event.result=handle.apply(cur,data);if(event.result===false){event.preventDefault();}}}event.type=type;// If nobody prevented the default action, do it now
	if(!onlyHandlers&&!event.isDefaultPrevented()){if((!special._default||special._default.apply(eventPath.pop(),data)===false)&&acceptData(elem)){// Call a native DOM method on the target with the same name as the event.
	// Don't do default actions on window, that's where global variables be (#6170)
	if(ontype&&jQuery.isFunction(elem[type])&&!jQuery.isWindow(elem)){// Don't re-trigger an onFOO event when we call its FOO() method
	tmp=elem[ontype];if(tmp){elem[ontype]=null;}// Prevent re-triggering of the same event, since we already bubbled it above
	jQuery.event.triggered=type;elem[type]();jQuery.event.triggered=undefined;if(tmp){elem[ontype]=tmp;}}}}return event.result;},// Piggyback on a donor event to simulate a different one
	// Used only for `focus(in | out)` events
	simulate:function simulate(type,elem,event){var e=jQuery.extend(new jQuery.Event(),event,{type:type,isSimulated:true});jQuery.event.trigger(e,null,elem);}});jQuery.fn.extend({trigger:function trigger(type,data){return this.each(function(){jQuery.event.trigger(type,data,this);});},triggerHandler:function triggerHandler(type,data){var elem=this[0];if(elem){return jQuery.event.trigger(type,data,elem,true);}}});jQuery.each(("blur focus focusin focusout resize scroll click dblclick "+"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave "+"change select submit keydown keypress keyup contextmenu").split(" "),function(i,name){// Handle event binding
	jQuery.fn[name]=function(data,fn){return arguments.length>0?this.on(name,null,data,fn):this.trigger(name);};});jQuery.fn.extend({hover:function hover(fnOver,fnOut){return this.mouseenter(fnOver).mouseleave(fnOut||fnOver);}});support.focusin="onfocusin"in window;// Support: Firefox <=44
	// Firefox doesn't have focus(in | out) events
	// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
	//
	// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
	// focus(in | out) events fire after focus & blur events,
	// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
	// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
	if(!support.focusin){jQuery.each({focus:"focusin",blur:"focusout"},function(orig,fix){// Attach a single capturing handler on the document while someone wants focusin/focusout
	var handler=function handler(event){jQuery.event.simulate(fix,event.target,jQuery.event.fix(event));};jQuery.event.special[fix]={setup:function setup(){var doc=this.ownerDocument||this,attaches=dataPriv.access(doc,fix);if(!attaches){doc.addEventListener(orig,handler,true);}dataPriv.access(doc,fix,(attaches||0)+1);},teardown:function teardown(){var doc=this.ownerDocument||this,attaches=dataPriv.access(doc,fix)-1;if(!attaches){doc.removeEventListener(orig,handler,true);dataPriv.remove(doc,fix);}else{dataPriv.access(doc,fix,attaches);}}};});}var location=window.location;var nonce=jQuery.now();var rquery=/\?/;// Cross-browser xml parsing
	jQuery.parseXML=function(data){var xml;if(!data||typeof data!=="string"){return null;}// Support: IE 9 - 11 only
	// IE throws on parseFromString with invalid input.
	try{xml=new window.DOMParser().parseFromString(data,"text/xml");}catch(e){xml=undefined;}if(!xml||xml.getElementsByTagName("parsererror").length){jQuery.error("Invalid XML: "+data);}return xml;};var rbracket=/\[\]$/,rCRLF=/\r?\n/g,rsubmitterTypes=/^(?:submit|button|image|reset|file)$/i,rsubmittable=/^(?:input|select|textarea|keygen)/i;function buildParams(prefix,obj,traditional,add){var name;if(jQuery.isArray(obj)){// Serialize array item.
	jQuery.each(obj,function(i,v){if(traditional||rbracket.test(prefix)){// Treat each array item as a scalar.
	add(prefix,v);}else{// Item is non-scalar (array or object), encode its numeric index.
	buildParams(prefix+"["+((typeof v==="undefined"?"undefined":_typeof(v))==="object"&&v!=null?i:"")+"]",v,traditional,add);}});}else if(!traditional&&jQuery.type(obj)==="object"){// Serialize object item.
	for(name in obj){buildParams(prefix+"["+name+"]",obj[name],traditional,add);}}else{// Serialize scalar item.
	add(prefix,obj);}}// Serialize an array of form elements or a set of
	// key/values into a query string
	jQuery.param=function(a,traditional){var prefix,s=[],add=function add(key,valueOrFunction){// If value is a function, invoke it and use its return value
	var value=jQuery.isFunction(valueOrFunction)?valueOrFunction():valueOrFunction;s[s.length]=encodeURIComponent(key)+"="+encodeURIComponent(value==null?"":value);};// If an array was passed in, assume that it is an array of form elements.
	if(jQuery.isArray(a)||a.jquery&&!jQuery.isPlainObject(a)){// Serialize the form elements
	jQuery.each(a,function(){add(this.name,this.value);});}else{// If traditional, encode the "old" way (the way 1.3.2 or older
	// did it), otherwise encode params recursively.
	for(prefix in a){buildParams(prefix,a[prefix],traditional,add);}}// Return the resulting serialization
	return s.join("&");};jQuery.fn.extend({serialize:function serialize(){return jQuery.param(this.serializeArray());},serializeArray:function serializeArray(){return this.map(function(){// Can add propHook for "elements" to filter or add form elements
	var elements=jQuery.prop(this,"elements");return elements?jQuery.makeArray(elements):this;}).filter(function(){var type=this.type;// Use .is( ":disabled" ) so that fieldset[disabled] works
	return this.name&&!jQuery(this).is(":disabled")&&rsubmittable.test(this.nodeName)&&!rsubmitterTypes.test(type)&&(this.checked||!rcheckableType.test(type));}).map(function(i,elem){var val=jQuery(this).val();return val==null?null:jQuery.isArray(val)?jQuery.map(val,function(val){return{name:elem.name,value:val.replace(rCRLF,"\r\n")};}):{name:elem.name,value:val.replace(rCRLF,"\r\n")};}).get();}});var r20=/%20/g,rhash=/#.*$/,rts=/([?&])_=[^&]*/,rheaders=/^(.*?):[ \t]*([^\r\n]*)$/mg,// #7653, #8125, #8152: local protocol detection
	rlocalProtocol=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,rnoContent=/^(?:GET|HEAD)$/,rprotocol=/^\/\//,/* Prefilters
		 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
		 * 2) These are called:
		 *    - BEFORE asking for a transport
		 *    - AFTER param serialization (s.data is a string if s.processData is true)
		 * 3) key is the dataType
		 * 4) the catchall symbol "*" can be used
		 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
		 */prefilters={},/* Transports bindings
		 * 1) key is the dataType
		 * 2) the catchall symbol "*" can be used
		 * 3) selection will start with transport dataType and THEN go to "*" if needed
		 */transports={},// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
	allTypes="*/".concat("*"),// Anchor tag for parsing the document origin
	originAnchor=document.createElement("a");originAnchor.href=location.href;// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
	function addToPrefiltersOrTransports(structure){// dataTypeExpression is optional and defaults to "*"
	return function(dataTypeExpression,func){if(typeof dataTypeExpression!=="string"){func=dataTypeExpression;dataTypeExpression="*";}var dataType,i=0,dataTypes=dataTypeExpression.toLowerCase().match(rnotwhite)||[];if(jQuery.isFunction(func)){// For each dataType in the dataTypeExpression
	while(dataType=dataTypes[i++]){// Prepend if requested
	if(dataType[0]==="+"){dataType=dataType.slice(1)||"*";(structure[dataType]=structure[dataType]||[]).unshift(func);// Otherwise append
	}else{(structure[dataType]=structure[dataType]||[]).push(func);}}}};}// Base inspection function for prefilters and transports
	function inspectPrefiltersOrTransports(structure,options,originalOptions,jqXHR){var inspected={},seekingTransport=structure===transports;function inspect(dataType){var selected;inspected[dataType]=true;jQuery.each(structure[dataType]||[],function(_,prefilterOrFactory){var dataTypeOrTransport=prefilterOrFactory(options,originalOptions,jqXHR);if(typeof dataTypeOrTransport==="string"&&!seekingTransport&&!inspected[dataTypeOrTransport]){options.dataTypes.unshift(dataTypeOrTransport);inspect(dataTypeOrTransport);return false;}else if(seekingTransport){return!(selected=dataTypeOrTransport);}});return selected;}return inspect(options.dataTypes[0])||!inspected["*"]&&inspect("*");}// A special extend for ajax options
	// that takes "flat" options (not to be deep extended)
	// Fixes #9887
	function ajaxExtend(target,src){var key,deep,flatOptions=jQuery.ajaxSettings.flatOptions||{};for(key in src){if(src[key]!==undefined){(flatOptions[key]?target:deep||(deep={}))[key]=src[key];}}if(deep){jQuery.extend(true,target,deep);}return target;}/* Handles responses to an ajax request:
	 * - finds the right dataType (mediates between content-type and expected dataType)
	 * - returns the corresponding response
	 */function ajaxHandleResponses(s,jqXHR,responses){var ct,type,finalDataType,firstDataType,contents=s.contents,dataTypes=s.dataTypes;// Remove auto dataType and get content-type in the process
	while(dataTypes[0]==="*"){dataTypes.shift();if(ct===undefined){ct=s.mimeType||jqXHR.getResponseHeader("Content-Type");}}// Check if we're dealing with a known content-type
	if(ct){for(type in contents){if(contents[type]&&contents[type].test(ct)){dataTypes.unshift(type);break;}}}// Check to see if we have a response for the expected dataType
	if(dataTypes[0]in responses){finalDataType=dataTypes[0];}else{// Try convertible dataTypes
	for(type in responses){if(!dataTypes[0]||s.converters[type+" "+dataTypes[0]]){finalDataType=type;break;}if(!firstDataType){firstDataType=type;}}// Or just use first one
	finalDataType=finalDataType||firstDataType;}// If we found a dataType
	// We add the dataType to the list if needed
	// and return the corresponding response
	if(finalDataType){if(finalDataType!==dataTypes[0]){dataTypes.unshift(finalDataType);}return responses[finalDataType];}}/* Chain conversions given the request and the original response
	 * Also sets the responseXXX fields on the jqXHR instance
	 */function ajaxConvert(s,response,jqXHR,isSuccess){var conv2,current,conv,tmp,prev,converters={},// Work with a copy of dataTypes in case we need to modify it for conversion
	dataTypes=s.dataTypes.slice();// Create converters map with lowercased keys
	if(dataTypes[1]){for(conv in s.converters){converters[conv.toLowerCase()]=s.converters[conv];}}current=dataTypes.shift();// Convert to each sequential dataType
	while(current){if(s.responseFields[current]){jqXHR[s.responseFields[current]]=response;}// Apply the dataFilter if provided
	if(!prev&&isSuccess&&s.dataFilter){response=s.dataFilter(response,s.dataType);}prev=current;current=dataTypes.shift();if(current){// There's only work to do if current dataType is non-auto
	if(current==="*"){current=prev;// Convert response if prev dataType is non-auto and differs from current
	}else if(prev!=="*"&&prev!==current){// Seek a direct converter
	conv=converters[prev+" "+current]||converters["* "+current];// If none found, seek a pair
	if(!conv){for(conv2 in converters){// If conv2 outputs current
	tmp=conv2.split(" ");if(tmp[1]===current){// If prev can be converted to accepted input
	conv=converters[prev+" "+tmp[0]]||converters["* "+tmp[0]];if(conv){// Condense equivalence converters
	if(conv===true){conv=converters[conv2];// Otherwise, insert the intermediate dataType
	}else if(converters[conv2]!==true){current=tmp[0];dataTypes.unshift(tmp[1]);}break;}}}}// Apply converter (if not an equivalence)
	if(conv!==true){// Unless errors are allowed to bubble, catch and return them
	if(conv&&s.throws){response=conv(response);}else{try{response=conv(response);}catch(e){return{state:"parsererror",error:conv?e:"No conversion from "+prev+" to "+current};}}}}}}return{state:"success",data:response};}jQuery.extend({// Counter for holding the number of active queries
	active:0,// Last-Modified header cache for next request
	lastModified:{},etag:{},ajaxSettings:{url:location.href,type:"GET",isLocal:rlocalProtocol.test(location.protocol),global:true,processData:true,async:true,contentType:"application/x-www-form-urlencoded; charset=UTF-8",/*
			timeout: 0,
			data: null,
			dataType: null,
			username: null,
			password: null,
			cache: null,
			throws: false,
			traditional: false,
			headers: {},
			*/accepts:{"*":allTypes,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},// Data converters
	// Keys separate source (or catchall "*") and destination types with a single space
	converters:{// Convert anything to text
	"* text":String,// Text to html (true = no transformation)
	"text html":true,// Evaluate text as a json expression
	"text json":JSON.parse,// Parse text as xml
	"text xml":jQuery.parseXML},// For options that shouldn't be deep extended:
	// you can add your own custom options here if
	// and when you create one that shouldn't be
	// deep extended (see ajaxExtend)
	flatOptions:{url:true,context:true}},// Creates a full fledged settings object into target
	// with both ajaxSettings and settings fields.
	// If target is omitted, writes into ajaxSettings.
	ajaxSetup:function ajaxSetup(target,settings){return settings?// Building a settings object
	ajaxExtend(ajaxExtend(target,jQuery.ajaxSettings),settings):// Extending ajaxSettings
	ajaxExtend(jQuery.ajaxSettings,target);},ajaxPrefilter:addToPrefiltersOrTransports(prefilters),ajaxTransport:addToPrefiltersOrTransports(transports),// Main method
	ajax:function ajax(url,options){// If url is an object, simulate pre-1.5 signature
	if((typeof url==="undefined"?"undefined":_typeof(url))==="object"){options=url;url=undefined;}// Force options to be an object
	options=options||{};var transport,// URL without anti-cache param
	cacheURL,// Response headers
	responseHeadersString,responseHeaders,// timeout handle
	timeoutTimer,// Url cleanup var
	urlAnchor,// Request state (becomes false upon send and true upon completion)
	completed,// To know if global events are to be dispatched
	fireGlobals,// Loop variable
	i,// uncached part of the url
	uncached,// Create the final options object
	s=jQuery.ajaxSetup({},options),// Callbacks context
	callbackContext=s.context||s,// Context for global events is callbackContext if it is a DOM node or jQuery collection
	globalEventContext=s.context&&(callbackContext.nodeType||callbackContext.jquery)?jQuery(callbackContext):jQuery.event,// Deferreds
	deferred=jQuery.Deferred(),completeDeferred=jQuery.Callbacks("once memory"),// Status-dependent callbacks
	_statusCode=s.statusCode||{},// Headers (they are sent all at once)
	requestHeaders={},requestHeadersNames={},// Default abort message
	strAbort="canceled",// Fake xhr
	jqXHR={readyState:0,// Builds headers hashtable if needed
	getResponseHeader:function getResponseHeader(key){var match;if(completed){if(!responseHeaders){responseHeaders={};while(match=rheaders.exec(responseHeadersString)){responseHeaders[match[1].toLowerCase()]=match[2];}}match=responseHeaders[key.toLowerCase()];}return match==null?null:match;},// Raw string
	getAllResponseHeaders:function getAllResponseHeaders(){return completed?responseHeadersString:null;},// Caches the header
	setRequestHeader:function setRequestHeader(name,value){if(completed==null){name=requestHeadersNames[name.toLowerCase()]=requestHeadersNames[name.toLowerCase()]||name;requestHeaders[name]=value;}return this;},// Overrides response content-type header
	overrideMimeType:function overrideMimeType(type){if(completed==null){s.mimeType=type;}return this;},// Status-dependent callbacks
	statusCode:function statusCode(map){var code;if(map){if(completed){// Execute the appropriate callbacks
	jqXHR.always(map[jqXHR.status]);}else{// Lazy-add the new callbacks in a way that preserves old ones
	for(code in map){_statusCode[code]=[_statusCode[code],map[code]];}}}return this;},// Cancel the request
	abort:function abort(statusText){var finalText=statusText||strAbort;if(transport){transport.abort(finalText);}done(0,finalText);return this;}};// Attach deferreds
	deferred.promise(jqXHR);// Add protocol if not provided (prefilters might expect it)
	// Handle falsy url in the settings object (#10093: consistency with old signature)
	// We also use the url parameter if available
	s.url=((url||s.url||location.href)+"").replace(rprotocol,location.protocol+"//");// Alias method option to type as per ticket #12004
	s.type=options.method||options.type||s.method||s.type;// Extract dataTypes list
	s.dataTypes=(s.dataType||"*").toLowerCase().match(rnotwhite)||[""];// A cross-domain request is in order when the origin doesn't match the current origin.
	if(s.crossDomain==null){urlAnchor=document.createElement("a");// Support: IE <=8 - 11, Edge 12 - 13
	// IE throws exception on accessing the href property if url is malformed,
	// e.g. http://example.com:80x/
	try{urlAnchor.href=s.url;// Support: IE <=8 - 11 only
	// Anchor's host property isn't correctly set when s.url is relative
	urlAnchor.href=urlAnchor.href;s.crossDomain=originAnchor.protocol+"//"+originAnchor.host!==urlAnchor.protocol+"//"+urlAnchor.host;}catch(e){// If there is an error parsing the URL, assume it is crossDomain,
	// it can be rejected by the transport if it is invalid
	s.crossDomain=true;}}// Convert data if not already a string
	if(s.data&&s.processData&&typeof s.data!=="string"){s.data=jQuery.param(s.data,s.traditional);}// Apply prefilters
	inspectPrefiltersOrTransports(prefilters,s,options,jqXHR);// If request was aborted inside a prefilter, stop there
	if(completed){return jqXHR;}// We can fire global events as of now if asked to
	// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
	fireGlobals=jQuery.event&&s.global;// Watch for a new set of requests
	if(fireGlobals&&jQuery.active++===0){jQuery.event.trigger("ajaxStart");}// Uppercase the type
	s.type=s.type.toUpperCase();// Determine if request has content
	s.hasContent=!rnoContent.test(s.type);// Save the URL in case we're toying with the If-Modified-Since
	// and/or If-None-Match header later on
	// Remove hash to simplify url manipulation
	cacheURL=s.url.replace(rhash,"");// More options handling for requests with no content
	if(!s.hasContent){// Remember the hash so we can put it back
	uncached=s.url.slice(cacheURL.length);// If data is available, append data to url
	if(s.data){cacheURL+=(rquery.test(cacheURL)?"&":"?")+s.data;// #9682: remove data so that it's not used in an eventual retry
	delete s.data;}// Add anti-cache in uncached url if needed
	if(s.cache===false){cacheURL=cacheURL.replace(rts,"");uncached=(rquery.test(cacheURL)?"&":"?")+"_="+nonce++ +uncached;}// Put hash and anti-cache on the URL that will be requested (gh-1732)
	s.url=cacheURL+uncached;// Change '%20' to '+' if this is encoded form body content (gh-2658)
	}else if(s.data&&s.processData&&(s.contentType||"").indexOf("application/x-www-form-urlencoded")===0){s.data=s.data.replace(r20,"+");}// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
	if(s.ifModified){if(jQuery.lastModified[cacheURL]){jqXHR.setRequestHeader("If-Modified-Since",jQuery.lastModified[cacheURL]);}if(jQuery.etag[cacheURL]){jqXHR.setRequestHeader("If-None-Match",jQuery.etag[cacheURL]);}}// Set the correct header, if data is being sent
	if(s.data&&s.hasContent&&s.contentType!==false||options.contentType){jqXHR.setRequestHeader("Content-Type",s.contentType);}// Set the Accepts header for the server, depending on the dataType
	jqXHR.setRequestHeader("Accept",s.dataTypes[0]&&s.accepts[s.dataTypes[0]]?s.accepts[s.dataTypes[0]]+(s.dataTypes[0]!=="*"?", "+allTypes+"; q=0.01":""):s.accepts["*"]);// Check for headers option
	for(i in s.headers){jqXHR.setRequestHeader(i,s.headers[i]);}// Allow custom headers/mimetypes and early abort
	if(s.beforeSend&&(s.beforeSend.call(callbackContext,jqXHR,s)===false||completed)){// Abort if not done already and return
	return jqXHR.abort();}// Aborting is no longer a cancellation
	strAbort="abort";// Install callbacks on deferreds
	completeDeferred.add(s.complete);jqXHR.done(s.success);jqXHR.fail(s.error);// Get transport
	transport=inspectPrefiltersOrTransports(transports,s,options,jqXHR);// If no transport, we auto-abort
	if(!transport){done(-1,"No Transport");}else{jqXHR.readyState=1;// Send global event
	if(fireGlobals){globalEventContext.trigger("ajaxSend",[jqXHR,s]);}// If request was aborted inside ajaxSend, stop there
	if(completed){return jqXHR;}// Timeout
	if(s.async&&s.timeout>0){timeoutTimer=window.setTimeout(function(){jqXHR.abort("timeout");},s.timeout);}try{completed=false;transport.send(requestHeaders,done);}catch(e){// Rethrow post-completion exceptions
	if(completed){throw e;}// Propagate others as results
	done(-1,e);}}// Callback for when everything is done
	function done(status,nativeStatusText,responses,headers){var isSuccess,success,error,response,modified,statusText=nativeStatusText;// Ignore repeat invocations
	if(completed){return;}completed=true;// Clear timeout if it exists
	if(timeoutTimer){window.clearTimeout(timeoutTimer);}// Dereference transport for early garbage collection
	// (no matter how long the jqXHR object will be used)
	transport=undefined;// Cache response headers
	responseHeadersString=headers||"";// Set readyState
	jqXHR.readyState=status>0?4:0;// Determine if successful
	isSuccess=status>=200&&status<300||status===304;// Get response data
	if(responses){response=ajaxHandleResponses(s,jqXHR,responses);}// Convert no matter what (that way responseXXX fields are always set)
	response=ajaxConvert(s,response,jqXHR,isSuccess);// If successful, handle type chaining
	if(isSuccess){// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
	if(s.ifModified){modified=jqXHR.getResponseHeader("Last-Modified");if(modified){jQuery.lastModified[cacheURL]=modified;}modified=jqXHR.getResponseHeader("etag");if(modified){jQuery.etag[cacheURL]=modified;}}// if no content
	if(status===204||s.type==="HEAD"){statusText="nocontent";// if not modified
	}else if(status===304){statusText="notmodified";// If we have data, let's convert it
	}else{statusText=response.state;success=response.data;error=response.error;isSuccess=!error;}}else{// Extract error from statusText and normalize for non-aborts
	error=statusText;if(status||!statusText){statusText="error";if(status<0){status=0;}}}// Set data for the fake xhr object
	jqXHR.status=status;jqXHR.statusText=(nativeStatusText||statusText)+"";// Success/Error
	if(isSuccess){deferred.resolveWith(callbackContext,[success,statusText,jqXHR]);}else{deferred.rejectWith(callbackContext,[jqXHR,statusText,error]);}// Status-dependent callbacks
	jqXHR.statusCode(_statusCode);_statusCode=undefined;if(fireGlobals){globalEventContext.trigger(isSuccess?"ajaxSuccess":"ajaxError",[jqXHR,s,isSuccess?success:error]);}// Complete
	completeDeferred.fireWith(callbackContext,[jqXHR,statusText]);if(fireGlobals){globalEventContext.trigger("ajaxComplete",[jqXHR,s]);// Handle the global AJAX counter
	if(! --jQuery.active){jQuery.event.trigger("ajaxStop");}}}return jqXHR;},getJSON:function getJSON(url,data,callback){return jQuery.get(url,data,callback,"json");},getScript:function getScript(url,callback){return jQuery.get(url,undefined,callback,"script");}});jQuery.each(["get","post"],function(i,method){jQuery[method]=function(url,data,callback,type){// Shift arguments if data argument was omitted
	if(jQuery.isFunction(data)){type=type||callback;callback=data;data=undefined;}// The url can be an options object (which then must have .url)
	return jQuery.ajax(jQuery.extend({url:url,type:method,dataType:type,data:data,success:callback},jQuery.isPlainObject(url)&&url));};});jQuery._evalUrl=function(url){return jQuery.ajax({url:url,// Make this explicit, since user can override this through ajaxSetup (#11264)
	type:"GET",dataType:"script",cache:true,async:false,global:false,"throws":true});};jQuery.fn.extend({wrapAll:function wrapAll(html){var wrap;if(this[0]){if(jQuery.isFunction(html)){html=html.call(this[0]);}// The elements to wrap the target around
	wrap=jQuery(html,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){wrap.insertBefore(this[0]);}wrap.map(function(){var elem=this;while(elem.firstElementChild){elem=elem.firstElementChild;}return elem;}).append(this);}return this;},wrapInner:function wrapInner(html){if(jQuery.isFunction(html)){return this.each(function(i){jQuery(this).wrapInner(html.call(this,i));});}return this.each(function(){var self=jQuery(this),contents=self.contents();if(contents.length){contents.wrapAll(html);}else{self.append(html);}});},wrap:function wrap(html){var isFunction=jQuery.isFunction(html);return this.each(function(i){jQuery(this).wrapAll(isFunction?html.call(this,i):html);});},unwrap:function unwrap(selector){this.parent(selector).not("body").each(function(){jQuery(this).replaceWith(this.childNodes);});return this;}});jQuery.expr.pseudos.hidden=function(elem){return!jQuery.expr.pseudos.visible(elem);};jQuery.expr.pseudos.visible=function(elem){return!!(elem.offsetWidth||elem.offsetHeight||elem.getClientRects().length);};jQuery.ajaxSettings.xhr=function(){try{return new window.XMLHttpRequest();}catch(e){}};var xhrSuccessStatus={// File protocol always yields status code 0, assume 200
	0:200,// Support: IE <=9 only
	// #1450: sometimes IE returns 1223 when it should be 204
	1223:204},xhrSupported=jQuery.ajaxSettings.xhr();support.cors=!!xhrSupported&&"withCredentials"in xhrSupported;support.ajax=xhrSupported=!!xhrSupported;jQuery.ajaxTransport(function(options){var _callback,errorCallback;// Cross domain only allowed if supported through XMLHttpRequest
	if(support.cors||xhrSupported&&!options.crossDomain){return{send:function send(headers,complete){var i,xhr=options.xhr();xhr.open(options.type,options.url,options.async,options.username,options.password);// Apply custom fields if provided
	if(options.xhrFields){for(i in options.xhrFields){xhr[i]=options.xhrFields[i];}}// Override mime type if needed
	if(options.mimeType&&xhr.overrideMimeType){xhr.overrideMimeType(options.mimeType);}// X-Requested-With header
	// For cross-domain requests, seeing as conditions for a preflight are
	// akin to a jigsaw puzzle, we simply never set it to be sure.
	// (it can always be set on a per-request basis or even using ajaxSetup)
	// For same-domain requests, won't change header if already provided.
	if(!options.crossDomain&&!headers["X-Requested-With"]){headers["X-Requested-With"]="XMLHttpRequest";}// Set headers
	for(i in headers){xhr.setRequestHeader(i,headers[i]);}// Callback
	_callback=function callback(type){return function(){if(_callback){_callback=errorCallback=xhr.onload=xhr.onerror=xhr.onabort=xhr.onreadystatechange=null;if(type==="abort"){xhr.abort();}else if(type==="error"){// Support: IE <=9 only
	// On a manual native abort, IE9 throws
	// errors on any property access that is not readyState
	if(typeof xhr.status!=="number"){complete(0,"error");}else{complete(// File: protocol always yields status 0; see #8605, #14207
	xhr.status,xhr.statusText);}}else{complete(xhrSuccessStatus[xhr.status]||xhr.status,xhr.statusText,// Support: IE <=9 only
	// IE9 has no XHR2 but throws on binary (trac-11426)
	// For XHR2 non-text, let the caller handle it (gh-2498)
	(xhr.responseType||"text")!=="text"||typeof xhr.responseText!=="string"?{binary:xhr.response}:{text:xhr.responseText},xhr.getAllResponseHeaders());}}};};// Listen to events
	xhr.onload=_callback();errorCallback=xhr.onerror=_callback("error");// Support: IE 9 only
	// Use onreadystatechange to replace onabort
	// to handle uncaught aborts
	if(xhr.onabort!==undefined){xhr.onabort=errorCallback;}else{xhr.onreadystatechange=function(){// Check readyState before timeout as it changes
	if(xhr.readyState===4){// Allow onerror to be called first,
	// but that will not handle a native abort
	// Also, save errorCallback to a variable
	// as xhr.onerror cannot be accessed
	window.setTimeout(function(){if(_callback){errorCallback();}});}};}// Create the abort callback
	_callback=_callback("abort");try{// Do send the request (this may raise an exception)
	xhr.send(options.hasContent&&options.data||null);}catch(e){// #14683: Only rethrow if this hasn't been notified as an error yet
	if(_callback){throw e;}}},abort:function abort(){if(_callback){_callback();}}};}});// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
	jQuery.ajaxPrefilter(function(s){if(s.crossDomain){s.contents.script=false;}});// Install script dataType
	jQuery.ajaxSetup({accepts:{script:"text/javascript, application/javascript, "+"application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function textScript(text){jQuery.globalEval(text);return text;}}});// Handle cache's special case and crossDomain
	jQuery.ajaxPrefilter("script",function(s){if(s.cache===undefined){s.cache=false;}if(s.crossDomain){s.type="GET";}});// Bind script tag hack transport
	jQuery.ajaxTransport("script",function(s){// This transport only deals with cross domain requests
	if(s.crossDomain){var script,_callback2;return{send:function send(_,complete){script=jQuery("<script>").prop({charset:s.scriptCharset,src:s.url}).on("load error",_callback2=function callback(evt){script.remove();_callback2=null;if(evt){complete(evt.type==="error"?404:200,evt.type);}});// Use native DOM manipulation to avoid our domManip AJAX trickery
	document.head.appendChild(script[0]);},abort:function abort(){if(_callback2){_callback2();}}};}});var oldCallbacks=[],rjsonp=/(=)\?(?=&|$)|\?\?/;// Default jsonp settings
	jQuery.ajaxSetup({jsonp:"callback",jsonpCallback:function jsonpCallback(){var callback=oldCallbacks.pop()||jQuery.expando+"_"+nonce++;this[callback]=true;return callback;}});// Detect, normalize options and install callbacks for jsonp requests
	jQuery.ajaxPrefilter("json jsonp",function(s,originalSettings,jqXHR){var callbackName,overwritten,responseContainer,jsonProp=s.jsonp!==false&&(rjsonp.test(s.url)?"url":typeof s.data==="string"&&(s.contentType||"").indexOf("application/x-www-form-urlencoded")===0&&rjsonp.test(s.data)&&"data");// Handle iff the expected data type is "jsonp" or we have a parameter to set
	if(jsonProp||s.dataTypes[0]==="jsonp"){// Get callback name, remembering preexisting value associated with it
	callbackName=s.jsonpCallback=jQuery.isFunction(s.jsonpCallback)?s.jsonpCallback():s.jsonpCallback;// Insert callback into url or form data
	if(jsonProp){s[jsonProp]=s[jsonProp].replace(rjsonp,"$1"+callbackName);}else if(s.jsonp!==false){s.url+=(rquery.test(s.url)?"&":"?")+s.jsonp+"="+callbackName;}// Use data converter to retrieve json after script execution
	s.converters["script json"]=function(){if(!responseContainer){jQuery.error(callbackName+" was not called");}return responseContainer[0];};// Force json dataType
	s.dataTypes[0]="json";// Install callback
	overwritten=window[callbackName];window[callbackName]=function(){responseContainer=arguments;};// Clean-up function (fires after converters)
	jqXHR.always(function(){// If previous value didn't exist - remove it
	if(overwritten===undefined){jQuery(window).removeProp(callbackName);// Otherwise restore preexisting value
	}else{window[callbackName]=overwritten;}// Save back as free
	if(s[callbackName]){// Make sure that re-using the options doesn't screw things around
	s.jsonpCallback=originalSettings.jsonpCallback;// Save the callback name for future use
	oldCallbacks.push(callbackName);}// Call if it was a function and we have a response
	if(responseContainer&&jQuery.isFunction(overwritten)){overwritten(responseContainer[0]);}responseContainer=overwritten=undefined;});// Delegate to script
	return"script";}});// Support: Safari 8 only
	// In Safari 8 documents created via document.implementation.createHTMLDocument
	// collapse sibling forms: the second one becomes a child of the first one.
	// Because of that, this security measure has to be disabled in Safari 8.
	// https://bugs.webkit.org/show_bug.cgi?id=137337
	support.createHTMLDocument=function(){var body=document.implementation.createHTMLDocument("").body;body.innerHTML="<form></form><form></form>";return body.childNodes.length===2;}();// Argument "data" should be string of html
	// context (optional): If specified, the fragment will be created in this context,
	// defaults to document
	// keepScripts (optional): If true, will include scripts passed in the html string
	jQuery.parseHTML=function(data,context,keepScripts){if(typeof data!=="string"){return[];}if(typeof context==="boolean"){keepScripts=context;context=false;}var base,parsed,scripts;if(!context){// Stop scripts or inline event handlers from being executed immediately
	// by using document.implementation
	if(support.createHTMLDocument){context=document.implementation.createHTMLDocument("");// Set the base href for the created document
	// so any parsed elements with URLs
	// are based on the document's URL (gh-2965)
	base=context.createElement("base");base.href=document.location.href;context.head.appendChild(base);}else{context=document;}}parsed=rsingleTag.exec(data);scripts=!keepScripts&&[];// Single tag
	if(parsed){return[context.createElement(parsed[1])];}parsed=buildFragment([data],context,scripts);if(scripts&&scripts.length){jQuery(scripts).remove();}return jQuery.merge([],parsed.childNodes);};/**
	 * Load a url into a page
	 */jQuery.fn.load=function(url,params,callback){var selector,type,response,self=this,off=url.indexOf(" ");if(off>-1){selector=jQuery.trim(url.slice(off));url=url.slice(0,off);}// If it's a function
	if(jQuery.isFunction(params)){// We assume that it's the callback
	callback=params;params=undefined;// Otherwise, build a param string
	}else if(params&&(typeof params==="undefined"?"undefined":_typeof(params))==="object"){type="POST";}// If we have elements to modify, make the request
	if(self.length>0){jQuery.ajax({url:url,// If "type" variable is undefined, then "GET" method will be used.
	// Make value of this field explicit since
	// user can override it through ajaxSetup method
	type:type||"GET",dataType:"html",data:params}).done(function(responseText){// Save response for use in complete callback
	response=arguments;self.html(selector?// If a selector was specified, locate the right elements in a dummy div
	// Exclude scripts to avoid IE 'Permission Denied' errors
	jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector):// Otherwise use the full result
	responseText);// If the request succeeds, this function gets "data", "status", "jqXHR"
	// but they are ignored because response was set above.
	// If it fails, this function gets "jqXHR", "status", "error"
	}).always(callback&&function(jqXHR,status){self.each(function(){callback.apply(this,response||[jqXHR.responseText,status,jqXHR]);});});}return this;};// Attach a bunch of functions for handling common AJAX events
	jQuery.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(i,type){jQuery.fn[type]=function(fn){return this.on(type,fn);};});jQuery.expr.pseudos.animated=function(elem){return jQuery.grep(jQuery.timers,function(fn){return elem===fn.elem;}).length;};/**
	 * Gets a window from an element
	 */function getWindow(elem){return jQuery.isWindow(elem)?elem:elem.nodeType===9&&elem.defaultView;}jQuery.offset={setOffset:function setOffset(elem,options,i){var curPosition,curLeft,curCSSTop,curTop,curOffset,curCSSLeft,calculatePosition,position=jQuery.css(elem,"position"),curElem=jQuery(elem),props={};// Set position first, in-case top/left are set even on static elem
	if(position==="static"){elem.style.position="relative";}curOffset=curElem.offset();curCSSTop=jQuery.css(elem,"top");curCSSLeft=jQuery.css(elem,"left");calculatePosition=(position==="absolute"||position==="fixed")&&(curCSSTop+curCSSLeft).indexOf("auto")>-1;// Need to be able to calculate position if either
	// top or left is auto and position is either absolute or fixed
	if(calculatePosition){curPosition=curElem.position();curTop=curPosition.top;curLeft=curPosition.left;}else{curTop=parseFloat(curCSSTop)||0;curLeft=parseFloat(curCSSLeft)||0;}if(jQuery.isFunction(options)){// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
	options=options.call(elem,i,jQuery.extend({},curOffset));}if(options.top!=null){props.top=options.top-curOffset.top+curTop;}if(options.left!=null){props.left=options.left-curOffset.left+curLeft;}if("using"in options){options.using.call(elem,props);}else{curElem.css(props);}}};jQuery.fn.extend({offset:function offset(options){// Preserve chaining for setter
	if(arguments.length){return options===undefined?this:this.each(function(i){jQuery.offset.setOffset(this,options,i);});}var docElem,win,rect,doc,elem=this[0];if(!elem){return;}// Support: IE <=11 only
	// Running getBoundingClientRect on a
	// disconnected node in IE throws an error
	if(!elem.getClientRects().length){return{top:0,left:0};}rect=elem.getBoundingClientRect();// Make sure element is not hidden (display: none)
	if(rect.width||rect.height){doc=elem.ownerDocument;win=getWindow(doc);docElem=doc.documentElement;return{top:rect.top+win.pageYOffset-docElem.clientTop,left:rect.left+win.pageXOffset-docElem.clientLeft};}// Return zeros for disconnected and hidden elements (gh-2310)
	return rect;},position:function position(){if(!this[0]){return;}var offsetParent,offset,elem=this[0],parentOffset={top:0,left:0};// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
	// because it is its only offset parent
	if(jQuery.css(elem,"position")==="fixed"){// Assume getBoundingClientRect is there when computed position is fixed
	offset=elem.getBoundingClientRect();}else{// Get *real* offsetParent
	offsetParent=this.offsetParent();// Get correct offsets
	offset=this.offset();if(!jQuery.nodeName(offsetParent[0],"html")){parentOffset=offsetParent.offset();}// Add offsetParent borders
	parentOffset={top:parentOffset.top+jQuery.css(offsetParent[0],"borderTopWidth",true),left:parentOffset.left+jQuery.css(offsetParent[0],"borderLeftWidth",true)};}// Subtract parent offsets and element margins
	return{top:offset.top-parentOffset.top-jQuery.css(elem,"marginTop",true),left:offset.left-parentOffset.left-jQuery.css(elem,"marginLeft",true)};},// This method will return documentElement in the following cases:
	// 1) For the element inside the iframe without offsetParent, this method will return
	//    documentElement of the parent window
	// 2) For the hidden or detached element
	// 3) For body or html element, i.e. in case of the html node - it will return itself
	//
	// but those exceptions were never presented as a real life use-cases
	// and might be considered as more preferable results.
	//
	// This logic, however, is not guaranteed and can change at any point in the future
	offsetParent:function offsetParent(){return this.map(function(){var offsetParent=this.offsetParent;while(offsetParent&&jQuery.css(offsetParent,"position")==="static"){offsetParent=offsetParent.offsetParent;}return offsetParent||documentElement;});}});// Create scrollLeft and scrollTop methods
	jQuery.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(method,prop){var top="pageYOffset"===prop;jQuery.fn[method]=function(val){return access(this,function(elem,method,val){var win=getWindow(elem);if(val===undefined){return win?win[prop]:elem[method];}if(win){win.scrollTo(!top?val:win.pageXOffset,top?val:win.pageYOffset);}else{elem[method]=val;}},method,val,arguments.length);};});// Support: Safari <=7 - 9.1, Chrome <=37 - 49
	// Add the top/left cssHooks using jQuery.fn.position
	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
	// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
	// getComputedStyle returns percent when specified for top/left/bottom/right;
	// rather than make the css module depend on the offset module, just check for it here
	jQuery.each(["top","left"],function(i,prop){jQuery.cssHooks[prop]=addGetHookIf(support.pixelPosition,function(elem,computed){if(computed){computed=curCSS(elem,prop);// If curCSS returns percentage, fallback to offset
	return rnumnonpx.test(computed)?jQuery(elem).position()[prop]+"px":computed;}});});// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
	jQuery.each({Height:"height",Width:"width"},function(name,type){jQuery.each({padding:"inner"+name,content:type,"":"outer"+name},function(defaultExtra,funcName){// Margin is only for outerHeight, outerWidth
	jQuery.fn[funcName]=function(margin,value){var chainable=arguments.length&&(defaultExtra||typeof margin!=="boolean"),extra=defaultExtra||(margin===true||value===true?"margin":"border");return access(this,function(elem,type,value){var doc;if(jQuery.isWindow(elem)){// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
	return funcName.indexOf("outer")===0?elem["inner"+name]:elem.document.documentElement["client"+name];}// Get document width or height
	if(elem.nodeType===9){doc=elem.documentElement;// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
	// whichever is greatest
	return Math.max(elem.body["scroll"+name],doc["scroll"+name],elem.body["offset"+name],doc["offset"+name],doc["client"+name]);}return value===undefined?// Get width or height on the element, requesting but not forcing parseFloat
	jQuery.css(elem,type,extra):// Set width or height on the element
	jQuery.style(elem,type,value,extra);},type,chainable?margin:undefined,chainable);};});});jQuery.fn.extend({bind:function bind(types,data,fn){return this.on(types,null,data,fn);},unbind:function unbind(types,fn){return this.off(types,null,fn);},delegate:function delegate(selector,types,data,fn){return this.on(types,selector,data,fn);},undelegate:function undelegate(selector,types,fn){// ( namespace ) or ( selector, types [, fn] )
	return arguments.length===1?this.off(selector,"**"):this.off(types,selector||"**",fn);}});jQuery.parseJSON=JSON.parse;// Register as a named AMD module, since jQuery can be concatenated with other
	// files that may use define, but not via a proper concatenation script that
	// understands anonymous AMD modules. A named AMD is safest and most robust
	// way to register. Lowercase jquery is used because AMD module names are
	// derived from file names, and jQuery is normally delivered in a lowercase
	// file name. Do this after creating the global so that if an AMD module wants
	// to call noConflict to hide this version of jQuery, it will work.
	// Note that for maximum portability, libraries that are not jQuery should
	// declare themselves as anonymous modules, and avoid setting a global if an
	// AMD loader is present. jQuery is a special case. For more information, see
	// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
	if(true){!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function(){return jQuery;}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));}var// Map over jQuery in case of overwrite
	_jQuery=window.jQuery,// Map over the $ in case of overwrite
	_$=window.$;jQuery.noConflict=function(deep){if(window.$===jQuery){window.$=_$;}if(deep&&window.jQuery===jQuery){window.jQuery=_jQuery;}return jQuery;};// Expose jQuery and $ identifiers, even in AMD
	// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
	// and CommonJS for browser emulators (#13566)
	if(!noGlobal){window.jQuery=window.$=jQuery;}return jQuery;});
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 9 */
/***/ function(module, exports) {

	"use strict";

	module.exports = function (module) {
		if (!module.webpackPolyfill) {
			module.deprecate = function () {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	};

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	// A library of seedable RNGs implemented in Javascript.
	//
	// Usage:
	//
	// var seedrandom = require('seedrandom');
	// var random = seedrandom(1); // or any seed.
	// var x = random();       // 0 <= x < 1.  Every bit is random.
	// var x = random.quick(); // 0 <= x < 1.  32 bits of randomness.

	// alea, a 53-bit multiply-with-carry generator by Johannes Baagøe.
	// Period: ~2^116
	// Reported to pass all BigCrush tests.
	var alea = __webpack_require__(11);

	// xor128, a pure xor-shift generator by George Marsaglia.
	// Period: 2^128-1.
	// Reported to fail: MatrixRank and LinearComp.
	var xor128 = __webpack_require__(14);

	// xorwow, George Marsaglia's 160-bit xor-shift combined plus weyl.
	// Period: 2^192-2^32
	// Reported to fail: CollisionOver, SimpPoker, and LinearComp.
	var xorwow = __webpack_require__(15);

	// xorshift7, by François Panneton and Pierre L'ecuyer, takes
	// a different approach: it adds robustness by allowing more shifts
	// than Marsaglia's original three.  It is a 7-shift generator
	// with 256 bits, that passes BigCrush with no systmatic failures.
	// Period 2^256-1.
	// No systematic BigCrush failures reported.
	var xorshift7 = __webpack_require__(16);

	// xor4096, by Richard Brent, is a 4096-bit xor-shift with a
	// very long period that also adds a Weyl generator. It also passes
	// BigCrush with no systematic failures.  Its long period may
	// be useful if you have many generators and need to avoid
	// collisions.
	// Period: 2^4128-2^32.
	// No systematic BigCrush failures reported.
	var xor4096 = __webpack_require__(17);

	// Tyche-i, by Samuel Neves and Filipe Araujo, is a bit-shifting random
	// number generator derived from ChaCha, a modern stream cipher.
	// https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf
	// Period: ~2^127
	// No systematic BigCrush failures reported.
	var tychei = __webpack_require__(18);

	// The original ARC4-based prng included in this library.
	// Period: ~2^1600
	var sr = __webpack_require__(19);

	sr.alea = alea;
	sr.xor128 = xor128;
	sr.xorwow = xorwow;
	sr.xorshift7 = xorshift7;
	sr.xor4096 = xor4096;
	sr.tychei = tychei;

	module.exports = sr;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A port of an algorithm by Johannes Baagøe <baagoe@baagoe.com>, 2010
	// http://baagoe.com/en/RandomMusings/javascript/
	// https://github.com/nquinlan/better-random-numbers-for-javascript-mirror
	// Original work is under MIT license -

	// Copyright (C) 2010 by Johannes Baagøe <baagoe@baagoe.org>
	//
	// Permission is hereby granted, free of charge, to any person obtaining a copy
	// of this software and associated documentation files (the "Software"), to deal
	// in the Software without restriction, including without limitation the rights
	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	// copies of the Software, and to permit persons to whom the Software is
	// furnished to do so, subject to the following conditions:
	//
	// The above copyright notice and this permission notice shall be included in
	// all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	// THE SOFTWARE.

	(function (global, module, define) {

	  function Alea(seed) {
	    var me = this,
	        mash = Mash();

	    me.next = function () {
	      var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32
	      me.s0 = me.s1;
	      me.s1 = me.s2;
	      return me.s2 = t - (me.c = t | 0);
	    };

	    // Apply the seeding algorithm from Baagoe.
	    me.c = 1;
	    me.s0 = mash(' ');
	    me.s1 = mash(' ');
	    me.s2 = mash(' ');
	    me.s0 -= mash(seed);
	    if (me.s0 < 0) {
	      me.s0 += 1;
	    }
	    me.s1 -= mash(seed);
	    if (me.s1 < 0) {
	      me.s1 += 1;
	    }
	    me.s2 -= mash(seed);
	    if (me.s2 < 0) {
	      me.s2 += 1;
	    }
	    mash = null;
	  }

	  function copy(f, t) {
	    t.c = f.c;
	    t.s0 = f.s0;
	    t.s1 = f.s1;
	    t.s2 = f.s2;
	    return t;
	  }

	  function impl(seed, opts) {
	    var xg = new Alea(seed),
	        state = opts && opts.state,
	        prng = xg.next;
	    prng.int32 = function () {
	      return xg.next() * 0x100000000 | 0;
	    };
	    prng.double = function () {
	      return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53
	    };
	    prng.quick = prng;
	    if (state) {
	      if ((typeof state === 'undefined' ? 'undefined' : _typeof(state)) == 'object') copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  function Mash() {
	    var n = 0xefc8249d;

	    var mash = function mash(data) {
	      data = data.toString();
	      for (var i = 0; i < data.length; i++) {
	        n += data.charCodeAt(i);
	        var h = 0.02519603282416938 * n;
	        n = h >>> 0;
	        h -= n;
	        h *= n;
	        n = h >>> 0;
	        h -= n;
	        n += h * 0x100000000; // 2^32
	      }
	      return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
	    };

	    return mash;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.alea = impl;
	  }
	})(undefined, ( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 12 */
/***/ function(module, exports) {

	module.exports = function() { throw new Error("define cannot be used indirect"); };


/***/ },
/* 13 */
/***/ function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;

	/* WEBPACK VAR INJECTION */}.call(exports, {}))

/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A Javascript implementaion of the "xor128" prng algorithm by
	// George Marsaglia.  See http://www.jstatsoft.org/v08/i14/paper

	(function (global, module, define) {

	  function XorGen(seed) {
	    var me = this,
	        strseed = '';

	    me.x = 0;
	    me.y = 0;
	    me.z = 0;
	    me.w = 0;

	    // Set up generator function.
	    me.next = function () {
	      var t = me.x ^ me.x << 11;
	      me.x = me.y;
	      me.y = me.z;
	      me.z = me.w;
	      return me.w ^= me.w >>> 19 ^ t ^ t >>> 8;
	    };

	    if (seed === (seed | 0)) {
	      // Integer seed.
	      me.x = seed;
	    } else {
	      // String seed.
	      strseed += seed;
	    }

	    // Mix in string seed, then discard an initial batch of 64 values.
	    for (var k = 0; k < strseed.length + 64; k++) {
	      me.x ^= strseed.charCodeAt(k) | 0;
	      me.next();
	    }
	  }

	  function copy(f, t) {
	    t.x = f.x;
	    t.y = f.y;
	    t.z = f.z;
	    t.w = f.w;
	    return t;
	  }

	  function impl(seed, opts) {
	    var xg = new XorGen(seed),
	        state = opts && opts.state,
	        prng = function prng() {
	      return (xg.next() >>> 0) / 0x100000000;
	    };
	    prng.double = function () {
	      do {
	        var top = xg.next() >>> 11,
	            bot = (xg.next() >>> 0) / 0x100000000,
	            result = (top + bot) / (1 << 21);
	      } while (result === 0);
	      return result;
	    };
	    prng.int32 = xg.next;
	    prng.quick = prng;
	    if (state) {
	      if ((typeof state === 'undefined' ? 'undefined' : _typeof(state)) == 'object') copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.xor128 = impl;
	  }
	})(undefined, ( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A Javascript implementaion of the "xorwow" prng algorithm by
	// George Marsaglia.  See http://www.jstatsoft.org/v08/i14/paper

	(function (global, module, define) {

	  function XorGen(seed) {
	    var me = this,
	        strseed = '';

	    // Set up generator function.
	    me.next = function () {
	      var t = me.x ^ me.x >>> 2;
	      me.x = me.y;me.y = me.z;me.z = me.w;me.w = me.v;
	      return (me.d = me.d + 362437 | 0) + (me.v = me.v ^ me.v << 4 ^ (t ^ t << 1)) | 0;
	    };

	    me.x = 0;
	    me.y = 0;
	    me.z = 0;
	    me.w = 0;
	    me.v = 0;

	    if (seed === (seed | 0)) {
	      // Integer seed.
	      me.x = seed;
	    } else {
	      // String seed.
	      strseed += seed;
	    }

	    // Mix in string seed, then discard an initial batch of 64 values.
	    for (var k = 0; k < strseed.length + 64; k++) {
	      me.x ^= strseed.charCodeAt(k) | 0;
	      if (k == strseed.length) {
	        me.d = me.x << 10 ^ me.x >>> 4;
	      }
	      me.next();
	    }
	  }

	  function copy(f, t) {
	    t.x = f.x;
	    t.y = f.y;
	    t.z = f.z;
	    t.w = f.w;
	    t.v = f.v;
	    t.d = f.d;
	    return t;
	  }

	  function impl(seed, opts) {
	    var xg = new XorGen(seed),
	        state = opts && opts.state,
	        prng = function prng() {
	      return (xg.next() >>> 0) / 0x100000000;
	    };
	    prng.double = function () {
	      do {
	        var top = xg.next() >>> 11,
	            bot = (xg.next() >>> 0) / 0x100000000,
	            result = (top + bot) / (1 << 21);
	      } while (result === 0);
	      return result;
	    };
	    prng.int32 = xg.next;
	    prng.quick = prng;
	    if (state) {
	      if ((typeof state === 'undefined' ? 'undefined' : _typeof(state)) == 'object') copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.xorwow = impl;
	  }
	})(undefined, ( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A Javascript implementaion of the "xorshift7" algorithm by
	// François Panneton and Pierre L'ecuyer:
	// "On the Xorgshift Random Number Generators"
	// http://saluc.engr.uconn.edu/refs/crypto/rng/panneton05onthexorshift.pdf

	(function (global, module, define) {

	  function XorGen(seed) {
	    var me = this;

	    // Set up generator function.
	    me.next = function () {
	      // Update xor generator.
	      var X = me.x,
	          i = me.i,
	          t,
	          v,
	          w;
	      t = X[i];t ^= t >>> 7;v = t ^ t << 24;
	      t = X[i + 1 & 7];v ^= t ^ t >>> 10;
	      t = X[i + 3 & 7];v ^= t ^ t >>> 3;
	      t = X[i + 4 & 7];v ^= t ^ t << 7;
	      t = X[i + 7 & 7];t = t ^ t << 13;v ^= t ^ t << 9;
	      X[i] = v;
	      me.i = i + 1 & 7;
	      return v;
	    };

	    function init(me, seed) {
	      var j,
	          w,
	          X = [];

	      if (seed === (seed | 0)) {
	        // Seed state array using a 32-bit integer.
	        w = X[0] = seed;
	      } else {
	        // Seed state using a string.
	        seed = '' + seed;
	        for (j = 0; j < seed.length; ++j) {
	          X[j & 7] = X[j & 7] << 15 ^ seed.charCodeAt(j) + X[j + 1 & 7] << 13;
	        }
	      }
	      // Enforce an array length of 8, not all zeroes.
	      while (X.length < 8) {
	        X.push(0);
	      }for (j = 0; j < 8 && X[j] === 0; ++j) {}
	      if (j == 8) w = X[7] = -1;else w = X[j];

	      me.x = X;
	      me.i = 0;

	      // Discard an initial 256 values.
	      for (j = 256; j > 0; --j) {
	        me.next();
	      }
	    }

	    init(me, seed);
	  }

	  function copy(f, t) {
	    t.x = f.x.slice();
	    t.i = f.i;
	    return t;
	  }

	  function impl(seed, opts) {
	    if (seed == null) seed = +new Date();
	    var xg = new XorGen(seed),
	        state = opts && opts.state,
	        prng = function prng() {
	      return (xg.next() >>> 0) / 0x100000000;
	    };
	    prng.double = function () {
	      do {
	        var top = xg.next() >>> 11,
	            bot = (xg.next() >>> 0) / 0x100000000,
	            result = (top + bot) / (1 << 21);
	      } while (result === 0);
	      return result;
	    };
	    prng.int32 = xg.next;
	    prng.quick = prng;
	    if (state) {
	      if (state.x) copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.xorshift7 = impl;
	  }
	})(undefined, ( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A Javascript implementaion of Richard Brent's Xorgens xor4096 algorithm.
	//
	// This fast non-cryptographic random number generator is designed for
	// use in Monte-Carlo algorithms. It combines a long-period xorshift
	// generator with a Weyl generator, and it passes all common batteries
	// of stasticial tests for randomness while consuming only a few nanoseconds
	// for each prng generated.  For background on the generator, see Brent's
	// paper: "Some long-period random number generators using shifts and xors."
	// http://arxiv.org/pdf/1104.3115.pdf
	//
	// Usage:
	//
	// var xor4096 = require('xor4096');
	// random = xor4096(1);                        // Seed with int32 or string.
	// assert.equal(random(), 0.1520436450538547); // (0, 1) range, 53 bits.
	// assert.equal(random.int32(), 1806534897);   // signed int32, 32 bits.
	//
	// For nonzero numeric keys, this impelementation provides a sequence
	// identical to that by Brent's xorgens 3 implementaion in C.  This
	// implementation also provides for initalizing the generator with
	// string seeds, or for saving and restoring the state of the generator.
	//
	// On Chrome, this prng benchmarks about 2.1 times slower than
	// Javascript's built-in Math.random().

	(function (global, module, define) {

	  function XorGen(seed) {
	    var me = this;

	    // Set up generator function.
	    me.next = function () {
	      var w = me.w,
	          X = me.X,
	          i = me.i,
	          t,
	          v;
	      // Update Weyl generator.
	      me.w = w = w + 0x61c88647 | 0;
	      // Update xor generator.
	      v = X[i + 34 & 127];
	      t = X[i = i + 1 & 127];
	      v ^= v << 13;
	      t ^= t << 17;
	      v ^= v >>> 15;
	      t ^= t >>> 12;
	      // Update Xor generator array state.
	      v = X[i] = v ^ t;
	      me.i = i;
	      // Result is the combination.
	      return v + (w ^ w >>> 16) | 0;
	    };

	    function init(me, seed) {
	      var t,
	          v,
	          i,
	          j,
	          w,
	          X = [],
	          limit = 128;
	      if (seed === (seed | 0)) {
	        // Numeric seeds initialize v, which is used to generates X.
	        v = seed;
	        seed = null;
	      } else {
	        // String seeds are mixed into v and X one character at a time.
	        seed = seed + '\0';
	        v = 0;
	        limit = Math.max(limit, seed.length);
	      }
	      // Initialize circular array and weyl value.
	      for (i = 0, j = -32; j < limit; ++j) {
	        // Put the unicode characters into the array, and shuffle them.
	        if (seed) v ^= seed.charCodeAt((j + 32) % seed.length);
	        // After 32 shuffles, take v as the starting w value.
	        if (j === 0) w = v;
	        v ^= v << 10;
	        v ^= v >>> 15;
	        v ^= v << 4;
	        v ^= v >>> 13;
	        if (j >= 0) {
	          w = w + 0x61c88647 | 0; // Weyl.
	          t = X[j & 127] ^= v + w; // Combine xor and weyl to init array.
	          i = 0 == t ? i + 1 : 0; // Count zeroes.
	        }
	      }
	      // We have detected all zeroes; make the key nonzero.
	      if (i >= 128) {
	        X[(seed && seed.length || 0) & 127] = -1;
	      }
	      // Run the generator 512 times to further mix the state before using it.
	      // Factoring this as a function slows the main generator, so it is just
	      // unrolled here.  The weyl generator is not advanced while warming up.
	      i = 127;
	      for (j = 4 * 128; j > 0; --j) {
	        v = X[i + 34 & 127];
	        t = X[i = i + 1 & 127];
	        v ^= v << 13;
	        t ^= t << 17;
	        v ^= v >>> 15;
	        t ^= t >>> 12;
	        X[i] = v ^ t;
	      }
	      // Storing state as object members is faster than using closure variables.
	      me.w = w;
	      me.X = X;
	      me.i = i;
	    }

	    init(me, seed);
	  }

	  function copy(f, t) {
	    t.i = f.i;
	    t.w = f.w;
	    t.X = f.X.slice();
	    return t;
	  };

	  function impl(seed, opts) {
	    if (seed == null) seed = +new Date();
	    var xg = new XorGen(seed),
	        state = opts && opts.state,
	        prng = function prng() {
	      return (xg.next() >>> 0) / 0x100000000;
	    };
	    prng.double = function () {
	      do {
	        var top = xg.next() >>> 11,
	            bot = (xg.next() >>> 0) / 0x100000000,
	            result = (top + bot) / (1 << 21);
	      } while (result === 0);
	      return result;
	    };
	    prng.int32 = xg.next;
	    prng.quick = prng;
	    if (state) {
	      if (state.X) copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.xor4096 = impl;
	  }
	})(undefined, // window object or global
	( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// A Javascript implementaion of the "Tyche-i" prng algorithm by
	// Samuel Neves and Filipe Araujo.
	// See https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf

	(function (global, module, define) {

	  function XorGen(seed) {
	    var me = this,
	        strseed = '';

	    // Set up generator function.
	    me.next = function () {
	      var b = me.b,
	          c = me.c,
	          d = me.d,
	          a = me.a;
	      b = b << 25 ^ b >>> 7 ^ c;
	      c = c - d | 0;
	      d = d << 24 ^ d >>> 8 ^ a;
	      a = a - b | 0;
	      me.b = b = b << 20 ^ b >>> 12 ^ c;
	      me.c = c = c - d | 0;
	      me.d = d << 16 ^ c >>> 16 ^ a;
	      return me.a = a - b | 0;
	    };

	    /* The following is non-inverted tyche, which has better internal
	     * bit diffusion, but which is about 25% slower than tyche-i in JS.
	    me.next = function() {
	      var a = me.a, b = me.b, c = me.c, d = me.d;
	      a = (me.a + me.b | 0) >>> 0;
	      d = me.d ^ a; d = d << 16 ^ d >>> 16;
	      c = me.c + d | 0;
	      b = me.b ^ c; b = b << 12 ^ d >>> 20;
	      me.a = a = a + b | 0;
	      d = d ^ a; me.d = d = d << 8 ^ d >>> 24;
	      me.c = c = c + d | 0;
	      b = b ^ c;
	      return me.b = (b << 7 ^ b >>> 25);
	    }
	    */

	    me.a = 0;
	    me.b = 0;
	    me.c = 2654435769 | 0;
	    me.d = 1367130551;

	    if (seed === Math.floor(seed)) {
	      // Integer seed.
	      me.a = seed / 0x100000000 | 0;
	      me.b = seed | 0;
	    } else {
	      // String seed.
	      strseed += seed;
	    }

	    // Mix in string seed, then discard an initial batch of 64 values.
	    for (var k = 0; k < strseed.length + 20; k++) {
	      me.b ^= strseed.charCodeAt(k) | 0;
	      me.next();
	    }
	  }

	  function copy(f, t) {
	    t.a = f.a;
	    t.b = f.b;
	    t.c = f.c;
	    t.d = f.d;
	    return t;
	  };

	  function impl(seed, opts) {
	    var xg = new XorGen(seed),
	        state = opts && opts.state,
	        prng = function prng() {
	      return (xg.next() >>> 0) / 0x100000000;
	    };
	    prng.double = function () {
	      do {
	        var top = xg.next() >>> 11,
	            bot = (xg.next() >>> 0) / 0x100000000,
	            result = (top + bot) / (1 << 21);
	      } while (result === 0);
	      return result;
	    };
	    prng.int32 = xg.next;
	    prng.quick = prng;
	    if (state) {
	      if ((typeof state === 'undefined' ? 'undefined' : _typeof(state)) == 'object') copy(state, xg);
	      prng.state = function () {
	        return copy(xg, {});
	      };
	    }
	    return prng;
	  }

	  if (module && module.exports) {
	    module.exports = impl;
	  } else if (__webpack_require__(12) && __webpack_require__(13)) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return impl;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  } else {
	    this.tychei = impl;
	  }
	})(undefined, ( false ? 'undefined' : _typeof(module)) == 'object' && module, // present in node.js
	__webpack_require__(12) // present with an AMD loader
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	/*
	Copyright 2014 David Bau.

	Permission is hereby granted, free of charge, to any person obtaining
	a copy of this software and associated documentation files (the
	"Software"), to deal in the Software without restriction, including
	without limitation the rights to use, copy, modify, merge, publish,
	distribute, sublicense, and/or sell copies of the Software, and to
	permit persons to whom the Software is furnished to do so, subject to
	the following conditions:

	The above copyright notice and this permission notice shall be
	included in all copies or substantial portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	*/

	(function (pool, math) {
	  //
	  // The following constants are related to IEEE 754 limits.
	  //
	  var global = this,
	      width = 256,
	      // each RC4 output is 0 <= x < 256
	  chunks = 6,
	      // at least six RC4 outputs for each double
	  digits = 52,
	      // there are 52 significant digits in a double
	  rngname = 'random',
	      // rngname: name for Math.random and Math.seedrandom
	  startdenom = math.pow(width, chunks),
	      significance = math.pow(2, digits),
	      overflow = significance * 2,
	      mask = width - 1,
	      nodecrypto; // node.js crypto module, initialized at the bottom.

	  //
	  // seedrandom()
	  // This is the seedrandom function described above.
	  //
	  function seedrandom(seed, options, callback) {
	    var key = [];
	    options = options == true ? { entropy: true } : options || {};

	    // Flatten the seed string or build one from local entropy if needed.
	    var shortseed = mixkey(flatten(options.entropy ? [seed, tostring(pool)] : seed == null ? autoseed() : seed, 3), key);

	    // Use the seed to initialize an ARC4 generator.
	    var arc4 = new ARC4(key);

	    // This function returns a random double in [0, 1) that contains
	    // randomness in every bit of the mantissa of the IEEE 754 value.
	    var prng = function prng() {
	      var n = arc4.g(chunks),
	          // Start with a numerator n < 2 ^ 48
	      d = startdenom,
	          //   and denominator d = 2 ^ 48.
	      x = 0; //   and no 'extra last byte'.
	      while (n < significance) {
	        // Fill up all significant digits by
	        n = (n + x) * width; //   shifting numerator and
	        d *= width; //   denominator and generating a
	        x = arc4.g(1); //   new least-significant-byte.
	      }
	      while (n >= overflow) {
	        // To avoid rounding up, before adding
	        n /= 2; //   last byte, shift everything
	        d /= 2; //   right using integer math until
	        x >>>= 1; //   we have exactly the desired bits.
	      }
	      return (n + x) / d; // Form the number within [0, 1).
	    };

	    prng.int32 = function () {
	      return arc4.g(4) | 0;
	    };
	    prng.quick = function () {
	      return arc4.g(4) / 0x100000000;
	    };
	    prng.double = prng;

	    // Mix the randomness into accumulated entropy.
	    mixkey(tostring(arc4.S), pool);

	    // Calling convention: what to return as a function of prng, seed, is_math.
	    return (options.pass || callback || function (prng, seed, is_math_call, state) {
	      if (state) {
	        // Load the arc4 state from the given state if it has an S array.
	        if (state.S) {
	          copy(state, arc4);
	        }
	        // Only provide the .state method if requested via options.state.
	        prng.state = function () {
	          return copy(arc4, {});
	        };
	      }

	      // If called as a method of Math (Math.seedrandom()), mutate
	      // Math.random because that is how seedrandom.js has worked since v1.0.
	      if (is_math_call) {
	        math[rngname] = prng;return seed;
	      }

	      // Otherwise, it is a newer calling convention, so return the
	      // prng directly.
	      else return prng;
	    })(prng, shortseed, 'global' in options ? options.global : this == math, options.state);
	  }
	  math['seed' + rngname] = seedrandom;

	  //
	  // ARC4
	  //
	  // An ARC4 implementation.  The constructor takes a key in the form of
	  // an array of at most (width) integers that should be 0 <= x < (width).
	  //
	  // The g(count) method returns a pseudorandom integer that concatenates
	  // the next (count) outputs from ARC4.  Its return value is a number x
	  // that is in the range 0 <= x < (width ^ count).
	  //
	  function ARC4(key) {
	    var t,
	        keylen = key.length,
	        me = this,
	        i = 0,
	        j = me.i = me.j = 0,
	        s = me.S = [];

	    // The empty key [] is treated as [0].
	    if (!keylen) {
	      key = [keylen++];
	    }

	    // Set up S using the standard key scheduling algorithm.
	    while (i < width) {
	      s[i] = i++;
	    }
	    for (i = 0; i < width; i++) {
	      s[i] = s[j = mask & j + key[i % keylen] + (t = s[i])];
	      s[j] = t;
	    }

	    // The "g" method returns the next (count) outputs as one number.
	    (me.g = function (count) {
	      // Using instance members instead of closure state nearly doubles speed.
	      var t,
	          r = 0,
	          i = me.i,
	          j = me.j,
	          s = me.S;
	      while (count--) {
	        t = s[i = mask & i + 1];
	        r = r * width + s[mask & (s[i] = s[j = mask & j + t]) + (s[j] = t)];
	      }
	      me.i = i;me.j = j;
	      return r;
	      // For robust unpredictability, the function call below automatically
	      // discards an initial batch of values.  This is called RC4-drop[256].
	      // See http://google.com/search?q=rsa+fluhrer+response&btnI
	    })(width);
	  }

	  //
	  // copy()
	  // Copies internal state of ARC4 to or from a plain object.
	  //
	  function copy(f, t) {
	    t.i = f.i;
	    t.j = f.j;
	    t.S = f.S.slice();
	    return t;
	  };

	  //
	  // flatten()
	  // Converts an object tree to nested arrays of strings.
	  //
	  function flatten(obj, depth) {
	    var result = [],
	        typ = typeof obj === 'undefined' ? 'undefined' : _typeof(obj),
	        prop;
	    if (depth && typ == 'object') {
	      for (prop in obj) {
	        try {
	          result.push(flatten(obj[prop], depth - 1));
	        } catch (e) {}
	      }
	    }
	    return result.length ? result : typ == 'string' ? obj : obj + '\0';
	  }

	  //
	  // mixkey()
	  // Mixes a string seed into a key that is an array of integers, and
	  // returns a shortened string seed that is equivalent to the result key.
	  //
	  function mixkey(seed, key) {
	    var stringseed = seed + '',
	        smear,
	        j = 0;
	    while (j < stringseed.length) {
	      key[mask & j] = mask & (smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++);
	    }
	    return tostring(key);
	  }

	  //
	  // autoseed()
	  // Returns an object for autoseeding, using window.crypto and Node crypto
	  // module if available.
	  //
	  function autoseed() {
	    try {
	      if (nodecrypto) {
	        return tostring(nodecrypto.randomBytes(width));
	      }
	      var out = new Uint8Array(width);
	      (global.crypto || global.msCrypto).getRandomValues(out);
	      return tostring(out);
	    } catch (e) {
	      var browser = global.navigator,
	          plugins = browser && browser.plugins;
	      return [+new Date(), global, plugins, global.screen, tostring(pool)];
	    }
	  }

	  //
	  // tostring()
	  // Converts an array of charcodes to a string
	  //
	  function tostring(a) {
	    return String.fromCharCode.apply(0, a);
	  }

	  //
	  // When seedrandom.js is loaded, we immediately mix a few bits
	  // from the built-in RNG into the entropy pool.  Because we do
	  // not want to interfere with deterministic PRNG state later,
	  // seedrandom will not call math.random on its own again after
	  // initialization.
	  //
	  mixkey(math.random(), pool);

	  //
	  // Nodejs and AMD support: export the implementation as a module using
	  // either convention.
	  //
	  if (( false ? 'undefined' : _typeof(module)) == 'object' && module.exports) {
	    module.exports = seedrandom;
	    // When in node.js, try using crypto package for autoseeding.
	    try {
	      nodecrypto = __webpack_require__(20);
	    } catch (ex) {}
	  } else if (true) {
	    !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	      return seedrandom;
	    }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	  }

	  // End anonymous scope, and pass initial values.
	})([], // pool: entropy pool starts empty
	Math // math: package containing random, pow, and seedrandom
	);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)(module)))

/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';

	var rng = __webpack_require__(25);

	function error() {
	  var m = [].slice.call(arguments).join(' ');
	  throw new Error([m, 'we accept pull requests', 'http://github.com/dominictarr/crypto-browserify'].join('\n'));
	}

	exports.createHash = __webpack_require__(27);

	exports.createHmac = __webpack_require__(39);

	exports.randomBytes = function (size, callback) {
	  if (callback && callback.call) {
	    try {
	      callback.call(this, undefined, new Buffer(rng(size)));
	    } catch (err) {
	      callback(err);
	    }
	  } else {
	    return new Buffer(rng(size));
	  }
	};

	function each(a, f) {
	  for (var i in a) {
	    f(a[i], i);
	  }
	}

	exports.getHashes = function () {
	  return ['sha1', 'sha256', 'sha512', 'md5', 'rmd160'];
	};

	var p = __webpack_require__(40)(exports);
	exports.pbkdf2 = p.pbkdf2;
	exports.pbkdf2Sync = p.pbkdf2Sync;

	// the least I can do is make error messages for the rest of the node.js/crypto api.
	each(['createCredentials', 'createCipher', 'createCipheriv', 'createDecipher', 'createDecipheriv', 'createSign', 'createVerify', 'createDiffieHellman'], function (name) {
	  exports[name] = function () {
	    error('sorry,', name, 'is not implemented yet');
	  };
	});
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer, global) {/*!
	 * The buffer module from node.js, for the browser.
	 *
	 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
	 * @license  MIT
	 */
	/* eslint-disable no-proto */

	'use strict';

	var base64 = __webpack_require__(22);
	var ieee754 = __webpack_require__(23);
	var isArray = __webpack_require__(24);

	exports.Buffer = Buffer;
	exports.SlowBuffer = SlowBuffer;
	exports.INSPECT_MAX_BYTES = 50;
	Buffer.poolSize = 8192; // not used by this implementation

	var rootParent = {};

	/**
	 * If `Buffer.TYPED_ARRAY_SUPPORT`:
	 *   === true    Use Uint8Array implementation (fastest)
	 *   === false   Use Object implementation (most compatible, even IE6)
	 *
	 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
	 * Opera 11.6+, iOS 4.2+.
	 *
	 * Due to various browser bugs, sometimes the Object implementation will be used even
	 * when the browser supports typed arrays.
	 *
	 * Note:
	 *
	 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
	 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
	 *
	 *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
	 *     on objects.
	 *
	 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
	 *
	 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
	 *     incorrect length in some situations.

	 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
	 * get the Object implementation, which is slower but behaves correctly.
	 */
	Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined ? global.TYPED_ARRAY_SUPPORT : typedArraySupport();

	function typedArraySupport() {
	  function Bar() {}
	  try {
	    var arr = new Uint8Array(1);
	    arr.foo = function () {
	      return 42;
	    };
	    arr.constructor = Bar;
	    return arr.foo() === 42 && // typed array instances can be augmented
	    arr.constructor === Bar && // constructor can be set
	    typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
	    arr.subarray(1, 1).byteLength === 0; // ie10 has broken `subarray`
	  } catch (e) {
	    return false;
	  }
	}

	function kMaxLength() {
	  return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;
	}

	/**
	 * Class: Buffer
	 * =============
	 *
	 * The Buffer constructor returns instances of `Uint8Array` that are augmented
	 * with function properties for all the node `Buffer` API functions. We use
	 * `Uint8Array` so that square bracket notation works as expected -- it returns
	 * a single octet.
	 *
	 * By augmenting the instances, we can avoid modifying the `Uint8Array`
	 * prototype.
	 */
	function Buffer(arg) {
	  if (!(this instanceof Buffer)) {
	    // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
	    if (arguments.length > 1) return new Buffer(arg, arguments[1]);
	    return new Buffer(arg);
	  }

	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
	    this.length = 0;
	    this.parent = undefined;
	  }

	  // Common case.
	  if (typeof arg === 'number') {
	    return fromNumber(this, arg);
	  }

	  // Slightly less common case.
	  if (typeof arg === 'string') {
	    return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8');
	  }

	  // Unusual.
	  return fromObject(this, arg);
	}

	function fromNumber(that, length) {
	  that = allocate(that, length < 0 ? 0 : checked(length) | 0);
	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
	    for (var i = 0; i < length; i++) {
	      that[i] = 0;
	    }
	  }
	  return that;
	}

	function fromString(that, string, encoding) {
	  if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8';

	  // Assumption: byteLength() return value is always < kMaxLength.
	  var length = byteLength(string, encoding) | 0;
	  that = allocate(that, length);

	  that.write(string, encoding);
	  return that;
	}

	function fromObject(that, object) {
	  if (Buffer.isBuffer(object)) return fromBuffer(that, object);

	  if (isArray(object)) return fromArray(that, object);

	  if (object == null) {
	    throw new TypeError('must start with number, buffer, array or string');
	  }

	  if (typeof ArrayBuffer !== 'undefined') {
	    if (object.buffer instanceof ArrayBuffer) {
	      return fromTypedArray(that, object);
	    }
	    if (object instanceof ArrayBuffer) {
	      return fromArrayBuffer(that, object);
	    }
	  }

	  if (object.length) return fromArrayLike(that, object);

	  return fromJsonObject(that, object);
	}

	function fromBuffer(that, buffer) {
	  var length = checked(buffer.length) | 0;
	  that = allocate(that, length);
	  buffer.copy(that, 0, 0, length);
	  return that;
	}

	function fromArray(that, array) {
	  var length = checked(array.length) | 0;
	  that = allocate(that, length);
	  for (var i = 0; i < length; i += 1) {
	    that[i] = array[i] & 255;
	  }
	  return that;
	}

	// Duplicate of fromArray() to keep fromArray() monomorphic.
	function fromTypedArray(that, array) {
	  var length = checked(array.length) | 0;
	  that = allocate(that, length);
	  // Truncating the elements is probably not what people expect from typed
	  // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
	  // of the old Buffer constructor.
	  for (var i = 0; i < length; i += 1) {
	    that[i] = array[i] & 255;
	  }
	  return that;
	}

	function fromArrayBuffer(that, array) {
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    // Return an augmented `Uint8Array` instance, for best performance
	    array.byteLength;
	    that = Buffer._augment(new Uint8Array(array));
	  } else {
	    // Fallback: Return an object instance of the Buffer class
	    that = fromTypedArray(that, new Uint8Array(array));
	  }
	  return that;
	}

	function fromArrayLike(that, array) {
	  var length = checked(array.length) | 0;
	  that = allocate(that, length);
	  for (var i = 0; i < length; i += 1) {
	    that[i] = array[i] & 255;
	  }
	  return that;
	}

	// Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
	// Returns a zero-length buffer for inputs that don't conform to the spec.
	function fromJsonObject(that, object) {
	  var array;
	  var length = 0;

	  if (object.type === 'Buffer' && isArray(object.data)) {
	    array = object.data;
	    length = checked(array.length) | 0;
	  }
	  that = allocate(that, length);

	  for (var i = 0; i < length; i += 1) {
	    that[i] = array[i] & 255;
	  }
	  return that;
	}

	if (Buffer.TYPED_ARRAY_SUPPORT) {
	  Buffer.prototype.__proto__ = Uint8Array.prototype;
	  Buffer.__proto__ = Uint8Array;
	} else {
	  // pre-set for values that may exist in the future
	  Buffer.prototype.length = undefined;
	  Buffer.prototype.parent = undefined;
	}

	function allocate(that, length) {
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    // Return an augmented `Uint8Array` instance, for best performance
	    that = Buffer._augment(new Uint8Array(length));
	    that.__proto__ = Buffer.prototype;
	  } else {
	    // Fallback: Return an object instance of the Buffer class
	    that.length = length;
	    that._isBuffer = true;
	  }

	  var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1;
	  if (fromPool) that.parent = rootParent;

	  return that;
	}

	function checked(length) {
	  // Note: cannot use `length < kMaxLength` here because that fails when
	  // length is NaN (which is otherwise coerced to zero.)
	  if (length >= kMaxLength()) {
	    throw new RangeError('Attempt to allocate Buffer larger than maximum ' + 'size: 0x' + kMaxLength().toString(16) + ' bytes');
	  }
	  return length | 0;
	}

	function SlowBuffer(subject, encoding) {
	  if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding);

	  var buf = new Buffer(subject, encoding);
	  delete buf.parent;
	  return buf;
	}

	Buffer.isBuffer = function isBuffer(b) {
	  return !!(b != null && b._isBuffer);
	};

	Buffer.compare = function compare(a, b) {
	  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
	    throw new TypeError('Arguments must be Buffers');
	  }

	  if (a === b) return 0;

	  var x = a.length;
	  var y = b.length;

	  var i = 0;
	  var len = Math.min(x, y);
	  while (i < len) {
	    if (a[i] !== b[i]) break;

	    ++i;
	  }

	  if (i !== len) {
	    x = a[i];
	    y = b[i];
	  }

	  if (x < y) return -1;
	  if (y < x) return 1;
	  return 0;
	};

	Buffer.isEncoding = function isEncoding(encoding) {
	  switch (String(encoding).toLowerCase()) {
	    case 'hex':
	    case 'utf8':
	    case 'utf-8':
	    case 'ascii':
	    case 'binary':
	    case 'base64':
	    case 'raw':
	    case 'ucs2':
	    case 'ucs-2':
	    case 'utf16le':
	    case 'utf-16le':
	      return true;
	    default:
	      return false;
	  }
	};

	Buffer.concat = function concat(list, length) {
	  if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.');

	  if (list.length === 0) {
	    return new Buffer(0);
	  }

	  var i;
	  if (length === undefined) {
	    length = 0;
	    for (i = 0; i < list.length; i++) {
	      length += list[i].length;
	    }
	  }

	  var buf = new Buffer(length);
	  var pos = 0;
	  for (i = 0; i < list.length; i++) {
	    var item = list[i];
	    item.copy(buf, pos);
	    pos += item.length;
	  }
	  return buf;
	};

	function byteLength(string, encoding) {
	  if (typeof string !== 'string') string = '' + string;

	  var len = string.length;
	  if (len === 0) return 0;

	  // Use a for loop to avoid recursion
	  var loweredCase = false;
	  for (;;) {
	    switch (encoding) {
	      case 'ascii':
	      case 'binary':
	      // Deprecated
	      case 'raw':
	      case 'raws':
	        return len;
	      case 'utf8':
	      case 'utf-8':
	        return utf8ToBytes(string).length;
	      case 'ucs2':
	      case 'ucs-2':
	      case 'utf16le':
	      case 'utf-16le':
	        return len * 2;
	      case 'hex':
	        return len >>> 1;
	      case 'base64':
	        return base64ToBytes(string).length;
	      default:
	        if (loweredCase) return utf8ToBytes(string).length; // assume utf8
	        encoding = ('' + encoding).toLowerCase();
	        loweredCase = true;
	    }
	  }
	}
	Buffer.byteLength = byteLength;

	function slowToString(encoding, start, end) {
	  var loweredCase = false;

	  start = start | 0;
	  end = end === undefined || end === Infinity ? this.length : end | 0;

	  if (!encoding) encoding = 'utf8';
	  if (start < 0) start = 0;
	  if (end > this.length) end = this.length;
	  if (end <= start) return '';

	  while (true) {
	    switch (encoding) {
	      case 'hex':
	        return hexSlice(this, start, end);

	      case 'utf8':
	      case 'utf-8':
	        return utf8Slice(this, start, end);

	      case 'ascii':
	        return asciiSlice(this, start, end);

	      case 'binary':
	        return binarySlice(this, start, end);

	      case 'base64':
	        return base64Slice(this, start, end);

	      case 'ucs2':
	      case 'ucs-2':
	      case 'utf16le':
	      case 'utf-16le':
	        return utf16leSlice(this, start, end);

	      default:
	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
	        encoding = (encoding + '').toLowerCase();
	        loweredCase = true;
	    }
	  }
	}

	Buffer.prototype.toString = function toString() {
	  var length = this.length | 0;
	  if (length === 0) return '';
	  if (arguments.length === 0) return utf8Slice(this, 0, length);
	  return slowToString.apply(this, arguments);
	};

	Buffer.prototype.equals = function equals(b) {
	  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
	  if (this === b) return true;
	  return Buffer.compare(this, b) === 0;
	};

	Buffer.prototype.inspect = function inspect() {
	  var str = '';
	  var max = exports.INSPECT_MAX_BYTES;
	  if (this.length > 0) {
	    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
	    if (this.length > max) str += ' ... ';
	  }
	  return '<Buffer ' + str + '>';
	};

	Buffer.prototype.compare = function compare(b) {
	  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer');
	  if (this === b) return 0;
	  return Buffer.compare(this, b);
	};

	Buffer.prototype.indexOf = function indexOf(val, byteOffset) {
	  if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff;else if (byteOffset < -0x80000000) byteOffset = -0x80000000;
	  byteOffset >>= 0;

	  if (this.length === 0) return -1;
	  if (byteOffset >= this.length) return -1;

	  // Negative offsets start from the end of the buffer
	  if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0);

	  if (typeof val === 'string') {
	    if (val.length === 0) return -1; // special case: looking for empty string always fails
	    return String.prototype.indexOf.call(this, val, byteOffset);
	  }
	  if (Buffer.isBuffer(val)) {
	    return arrayIndexOf(this, val, byteOffset);
	  }
	  if (typeof val === 'number') {
	    if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') {
	      return Uint8Array.prototype.indexOf.call(this, val, byteOffset);
	    }
	    return arrayIndexOf(this, [val], byteOffset);
	  }

	  function arrayIndexOf(arr, val, byteOffset) {
	    var foundIndex = -1;
	    for (var i = 0; byteOffset + i < arr.length; i++) {
	      if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) {
	        if (foundIndex === -1) foundIndex = i;
	        if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex;
	      } else {
	        foundIndex = -1;
	      }
	    }
	    return -1;
	  }

	  throw new TypeError('val must be string, number or Buffer');
	};

	// `get` is deprecated
	Buffer.prototype.get = function get(offset) {
	  console.log('.get() is deprecated. Access using array indexes instead.');
	  return this.readUInt8(offset);
	};

	// `set` is deprecated
	Buffer.prototype.set = function set(v, offset) {
	  console.log('.set() is deprecated. Access using array indexes instead.');
	  return this.writeUInt8(v, offset);
	};

	function hexWrite(buf, string, offset, length) {
	  offset = Number(offset) || 0;
	  var remaining = buf.length - offset;
	  if (!length) {
	    length = remaining;
	  } else {
	    length = Number(length);
	    if (length > remaining) {
	      length = remaining;
	    }
	  }

	  // must be an even number of digits
	  var strLen = string.length;
	  if (strLen % 2 !== 0) throw new Error('Invalid hex string');

	  if (length > strLen / 2) {
	    length = strLen / 2;
	  }
	  for (var i = 0; i < length; i++) {
	    var parsed = parseInt(string.substr(i * 2, 2), 16);
	    if (isNaN(parsed)) throw new Error('Invalid hex string');
	    buf[offset + i] = parsed;
	  }
	  return i;
	}

	function utf8Write(buf, string, offset, length) {
	  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
	}

	function asciiWrite(buf, string, offset, length) {
	  return blitBuffer(asciiToBytes(string), buf, offset, length);
	}

	function binaryWrite(buf, string, offset, length) {
	  return asciiWrite(buf, string, offset, length);
	}

	function base64Write(buf, string, offset, length) {
	  return blitBuffer(base64ToBytes(string), buf, offset, length);
	}

	function ucs2Write(buf, string, offset, length) {
	  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
	}

	Buffer.prototype.write = function write(string, offset, length, encoding) {
	  // Buffer#write(string)
	  if (offset === undefined) {
	    encoding = 'utf8';
	    length = this.length;
	    offset = 0;
	    // Buffer#write(string, encoding)
	  } else if (length === undefined && typeof offset === 'string') {
	      encoding = offset;
	      length = this.length;
	      offset = 0;
	      // Buffer#write(string, offset[, length][, encoding])
	    } else if (isFinite(offset)) {
	        offset = offset | 0;
	        if (isFinite(length)) {
	          length = length | 0;
	          if (encoding === undefined) encoding = 'utf8';
	        } else {
	          encoding = length;
	          length = undefined;
	        }
	        // legacy write(string, encoding, offset, length) - remove in v0.13
	      } else {
	          var swap = encoding;
	          encoding = offset;
	          offset = length | 0;
	          length = swap;
	        }

	  var remaining = this.length - offset;
	  if (length === undefined || length > remaining) length = remaining;

	  if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
	    throw new RangeError('attempt to write outside buffer bounds');
	  }

	  if (!encoding) encoding = 'utf8';

	  var loweredCase = false;
	  for (;;) {
	    switch (encoding) {
	      case 'hex':
	        return hexWrite(this, string, offset, length);

	      case 'utf8':
	      case 'utf-8':
	        return utf8Write(this, string, offset, length);

	      case 'ascii':
	        return asciiWrite(this, string, offset, length);

	      case 'binary':
	        return binaryWrite(this, string, offset, length);

	      case 'base64':
	        // Warning: maxLength not taken into account in base64Write
	        return base64Write(this, string, offset, length);

	      case 'ucs2':
	      case 'ucs-2':
	      case 'utf16le':
	      case 'utf-16le':
	        return ucs2Write(this, string, offset, length);

	      default:
	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding);
	        encoding = ('' + encoding).toLowerCase();
	        loweredCase = true;
	    }
	  }
	};

	Buffer.prototype.toJSON = function toJSON() {
	  return {
	    type: 'Buffer',
	    data: Array.prototype.slice.call(this._arr || this, 0)
	  };
	};

	function base64Slice(buf, start, end) {
	  if (start === 0 && end === buf.length) {
	    return base64.fromByteArray(buf);
	  } else {
	    return base64.fromByteArray(buf.slice(start, end));
	  }
	}

	function utf8Slice(buf, start, end) {
	  end = Math.min(buf.length, end);
	  var res = [];

	  var i = start;
	  while (i < end) {
	    var firstByte = buf[i];
	    var codePoint = null;
	    var bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1;

	    if (i + bytesPerSequence <= end) {
	      var secondByte, thirdByte, fourthByte, tempCodePoint;

	      switch (bytesPerSequence) {
	        case 1:
	          if (firstByte < 0x80) {
	            codePoint = firstByte;
	          }
	          break;
	        case 2:
	          secondByte = buf[i + 1];
	          if ((secondByte & 0xC0) === 0x80) {
	            tempCodePoint = (firstByte & 0x1F) << 0x6 | secondByte & 0x3F;
	            if (tempCodePoint > 0x7F) {
	              codePoint = tempCodePoint;
	            }
	          }
	          break;
	        case 3:
	          secondByte = buf[i + 1];
	          thirdByte = buf[i + 2];
	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
	            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | thirdByte & 0x3F;
	            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
	              codePoint = tempCodePoint;
	            }
	          }
	          break;
	        case 4:
	          secondByte = buf[i + 1];
	          thirdByte = buf[i + 2];
	          fourthByte = buf[i + 3];
	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
	            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | fourthByte & 0x3F;
	            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
	              codePoint = tempCodePoint;
	            }
	          }
	      }
	    }

	    if (codePoint === null) {
	      // we did not generate a valid codePoint so insert a
	      // replacement char (U+FFFD) and advance only 1 byte
	      codePoint = 0xFFFD;
	      bytesPerSequence = 1;
	    } else if (codePoint > 0xFFFF) {
	      // encode to utf16 (surrogate pair dance)
	      codePoint -= 0x10000;
	      res.push(codePoint >>> 10 & 0x3FF | 0xD800);
	      codePoint = 0xDC00 | codePoint & 0x3FF;
	    }

	    res.push(codePoint);
	    i += bytesPerSequence;
	  }

	  return decodeCodePointsArray(res);
	}

	// Based on http://stackoverflow.com/a/22747272/680742, the browser with
	// the lowest limit is Chrome, with 0x10000 args.
	// We go 1 magnitude less, for safety
	var MAX_ARGUMENTS_LENGTH = 0x1000;

	function decodeCodePointsArray(codePoints) {
	  var len = codePoints.length;
	  if (len <= MAX_ARGUMENTS_LENGTH) {
	    return String.fromCharCode.apply(String, codePoints); // avoid extra slice()
	  }

	  // Decode in chunks to avoid "call stack size exceeded".
	  var res = '';
	  var i = 0;
	  while (i < len) {
	    res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
	  }
	  return res;
	}

	function asciiSlice(buf, start, end) {
	  var ret = '';
	  end = Math.min(buf.length, end);

	  for (var i = start; i < end; i++) {
	    ret += String.fromCharCode(buf[i] & 0x7F);
	  }
	  return ret;
	}

	function binarySlice(buf, start, end) {
	  var ret = '';
	  end = Math.min(buf.length, end);

	  for (var i = start; i < end; i++) {
	    ret += String.fromCharCode(buf[i]);
	  }
	  return ret;
	}

	function hexSlice(buf, start, end) {
	  var len = buf.length;

	  if (!start || start < 0) start = 0;
	  if (!end || end < 0 || end > len) end = len;

	  var out = '';
	  for (var i = start; i < end; i++) {
	    out += toHex(buf[i]);
	  }
	  return out;
	}

	function utf16leSlice(buf, start, end) {
	  var bytes = buf.slice(start, end);
	  var res = '';
	  for (var i = 0; i < bytes.length; i += 2) {
	    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
	  }
	  return res;
	}

	Buffer.prototype.slice = function slice(start, end) {
	  var len = this.length;
	  start = ~~start;
	  end = end === undefined ? len : ~~end;

	  if (start < 0) {
	    start += len;
	    if (start < 0) start = 0;
	  } else if (start > len) {
	    start = len;
	  }

	  if (end < 0) {
	    end += len;
	    if (end < 0) end = 0;
	  } else if (end > len) {
	    end = len;
	  }

	  if (end < start) end = start;

	  var newBuf;
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    newBuf = Buffer._augment(this.subarray(start, end));
	  } else {
	    var sliceLen = end - start;
	    newBuf = new Buffer(sliceLen, undefined);
	    for (var i = 0; i < sliceLen; i++) {
	      newBuf[i] = this[i + start];
	    }
	  }

	  if (newBuf.length) newBuf.parent = this.parent || this;

	  return newBuf;
	};

	/*
	 * Need to make sure that buffer isn't trying to write out of bounds.
	 */
	function checkOffset(offset, ext, length) {
	  if (offset % 1 !== 0 || offset < 0) throw new RangeError('offset is not uint');
	  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length');
	}

	Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) checkOffset(offset, byteLength, this.length);

	  var val = this[offset];
	  var mul = 1;
	  var i = 0;
	  while (++i < byteLength && (mul *= 0x100)) {
	    val += this[offset + i] * mul;
	  }

	  return val;
	};

	Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) {
	    checkOffset(offset, byteLength, this.length);
	  }

	  var val = this[offset + --byteLength];
	  var mul = 1;
	  while (byteLength > 0 && (mul *= 0x100)) {
	    val += this[offset + --byteLength] * mul;
	  }

	  return val;
	};

	Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 1, this.length);
	  return this[offset];
	};

	Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 2, this.length);
	  return this[offset] | this[offset + 1] << 8;
	};

	Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 2, this.length);
	  return this[offset] << 8 | this[offset + 1];
	};

	Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);

	  return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 0x1000000;
	};

	Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);

	  return this[offset] * 0x1000000 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
	};

	Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) checkOffset(offset, byteLength, this.length);

	  var val = this[offset];
	  var mul = 1;
	  var i = 0;
	  while (++i < byteLength && (mul *= 0x100)) {
	    val += this[offset + i] * mul;
	  }
	  mul *= 0x80;

	  if (val >= mul) val -= Math.pow(2, 8 * byteLength);

	  return val;
	};

	Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) checkOffset(offset, byteLength, this.length);

	  var i = byteLength;
	  var mul = 1;
	  var val = this[offset + --i];
	  while (i > 0 && (mul *= 0x100)) {
	    val += this[offset + --i] * mul;
	  }
	  mul *= 0x80;

	  if (val >= mul) val -= Math.pow(2, 8 * byteLength);

	  return val;
	};

	Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 1, this.length);
	  if (!(this[offset] & 0x80)) return this[offset];
	  return (0xff - this[offset] + 1) * -1;
	};

	Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 2, this.length);
	  var val = this[offset] | this[offset + 1] << 8;
	  return val & 0x8000 ? val | 0xFFFF0000 : val;
	};

	Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 2, this.length);
	  var val = this[offset + 1] | this[offset] << 8;
	  return val & 0x8000 ? val | 0xFFFF0000 : val;
	};

	Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);

	  return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
	};

	Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);

	  return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
	};

	Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);
	  return ieee754.read(this, offset, true, 23, 4);
	};

	Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 4, this.length);
	  return ieee754.read(this, offset, false, 23, 4);
	};

	Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 8, this.length);
	  return ieee754.read(this, offset, true, 52, 8);
	};

	Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
	  if (!noAssert) checkOffset(offset, 8, this.length);
	  return ieee754.read(this, offset, false, 52, 8);
	};

	function checkInt(buf, value, offset, ext, max, min) {
	  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance');
	  if (value > max || value < min) throw new RangeError('value is out of bounds');
	  if (offset + ext > buf.length) throw new RangeError('index out of range');
	}

	Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);

	  var mul = 1;
	  var i = 0;
	  this[offset] = value & 0xFF;
	  while (++i < byteLength && (mul *= 0x100)) {
	    this[offset + i] = value / mul & 0xFF;
	  }

	  return offset + byteLength;
	};

	Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  byteLength = byteLength | 0;
	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0);

	  var i = byteLength - 1;
	  var mul = 1;
	  this[offset + i] = value & 0xFF;
	  while (--i >= 0 && (mul *= 0x100)) {
	    this[offset + i] = value / mul & 0xFF;
	  }

	  return offset + byteLength;
	};

	Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
	  this[offset] = value & 0xff;
	  return offset + 1;
	};

	function objectWriteUInt16(buf, value, offset, littleEndian) {
	  if (value < 0) value = 0xffff + value + 1;
	  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
	    buf[offset + i] = (value & 0xff << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;
	  }
	}

	Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value & 0xff;
	    this[offset + 1] = value >>> 8;
	  } else {
	    objectWriteUInt16(this, value, offset, true);
	  }
	  return offset + 2;
	};

	Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value >>> 8;
	    this[offset + 1] = value & 0xff;
	  } else {
	    objectWriteUInt16(this, value, offset, false);
	  }
	  return offset + 2;
	};

	function objectWriteUInt32(buf, value, offset, littleEndian) {
	  if (value < 0) value = 0xffffffff + value + 1;
	  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
	    buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 0xff;
	  }
	}

	Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset + 3] = value >>> 24;
	    this[offset + 2] = value >>> 16;
	    this[offset + 1] = value >>> 8;
	    this[offset] = value & 0xff;
	  } else {
	    objectWriteUInt32(this, value, offset, true);
	  }
	  return offset + 4;
	};

	Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value >>> 24;
	    this[offset + 1] = value >>> 16;
	    this[offset + 2] = value >>> 8;
	    this[offset + 3] = value & 0xff;
	  } else {
	    objectWriteUInt32(this, value, offset, false);
	  }
	  return offset + 4;
	};

	Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) {
	    var limit = Math.pow(2, 8 * byteLength - 1);

	    checkInt(this, value, offset, byteLength, limit - 1, -limit);
	  }

	  var i = 0;
	  var mul = 1;
	  var sub = value < 0 ? 1 : 0;
	  this[offset] = value & 0xFF;
	  while (++i < byteLength && (mul *= 0x100)) {
	    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
	  }

	  return offset + byteLength;
	};

	Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) {
	    var limit = Math.pow(2, 8 * byteLength - 1);

	    checkInt(this, value, offset, byteLength, limit - 1, -limit);
	  }

	  var i = byteLength - 1;
	  var mul = 1;
	  var sub = value < 0 ? 1 : 0;
	  this[offset + i] = value & 0xFF;
	  while (--i >= 0 && (mul *= 0x100)) {
	    this[offset + i] = (value / mul >> 0) - sub & 0xFF;
	  }

	  return offset + byteLength;
	};

	Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
	  if (value < 0) value = 0xff + value + 1;
	  this[offset] = value & 0xff;
	  return offset + 1;
	};

	Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value & 0xff;
	    this[offset + 1] = value >>> 8;
	  } else {
	    objectWriteUInt16(this, value, offset, true);
	  }
	  return offset + 2;
	};

	Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value >>> 8;
	    this[offset + 1] = value & 0xff;
	  } else {
	    objectWriteUInt16(this, value, offset, false);
	  }
	  return offset + 2;
	};

	Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value & 0xff;
	    this[offset + 1] = value >>> 8;
	    this[offset + 2] = value >>> 16;
	    this[offset + 3] = value >>> 24;
	  } else {
	    objectWriteUInt32(this, value, offset, true);
	  }
	  return offset + 4;
	};

	Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
	  value = +value;
	  offset = offset | 0;
	  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
	  if (value < 0) value = 0xffffffff + value + 1;
	  if (Buffer.TYPED_ARRAY_SUPPORT) {
	    this[offset] = value >>> 24;
	    this[offset + 1] = value >>> 16;
	    this[offset + 2] = value >>> 8;
	    this[offset + 3] = value & 0xff;
	  } else {
	    objectWriteUInt32(this, value, offset, false);
	  }
	  return offset + 4;
	};

	function checkIEEE754(buf, value, offset, ext, max, min) {
	  if (value > max || value < min) throw new RangeError('value is out of bounds');
	  if (offset + ext > buf.length) throw new RangeError('index out of range');
	  if (offset < 0) throw new RangeError('index out of range');
	}

	function writeFloat(buf, value, offset, littleEndian, noAssert) {
	  if (!noAssert) {
	    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38);
	  }
	  ieee754.write(buf, value, offset, littleEndian, 23, 4);
	  return offset + 4;
	}

	Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
	  return writeFloat(this, value, offset, true, noAssert);
	};

	Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
	  return writeFloat(this, value, offset, false, noAssert);
	};

	function writeDouble(buf, value, offset, littleEndian, noAssert) {
	  if (!noAssert) {
	    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308);
	  }
	  ieee754.write(buf, value, offset, littleEndian, 52, 8);
	  return offset + 8;
	}

	Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
	  return writeDouble(this, value, offset, true, noAssert);
	};

	Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
	  return writeDouble(this, value, offset, false, noAssert);
	};

	// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
	Buffer.prototype.copy = function copy(target, targetStart, start, end) {
	  if (!start) start = 0;
	  if (!end && end !== 0) end = this.length;
	  if (targetStart >= target.length) targetStart = target.length;
	  if (!targetStart) targetStart = 0;
	  if (end > 0 && end < start) end = start;

	  // Copy 0 bytes; we're done
	  if (end === start) return 0;
	  if (target.length === 0 || this.length === 0) return 0;

	  // Fatal error conditions
	  if (targetStart < 0) {
	    throw new RangeError('targetStart out of bounds');
	  }
	  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds');
	  if (end < 0) throw new RangeError('sourceEnd out of bounds');

	  // Are we oob?
	  if (end > this.length) end = this.length;
	  if (target.length - targetStart < end - start) {
	    end = target.length - targetStart + start;
	  }

	  var len = end - start;
	  var i;

	  if (this === target && start < targetStart && targetStart < end) {
	    // descending copy from end
	    for (i = len - 1; i >= 0; i--) {
	      target[i + targetStart] = this[i + start];
	    }
	  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
	    // ascending copy from start
	    for (i = 0; i < len; i++) {
	      target[i + targetStart] = this[i + start];
	    }
	  } else {
	    target._set(this.subarray(start, start + len), targetStart);
	  }

	  return len;
	};

	// fill(value, start=0, end=buffer.length)
	Buffer.prototype.fill = function fill(value, start, end) {
	  if (!value) value = 0;
	  if (!start) start = 0;
	  if (!end) end = this.length;

	  if (end < start) throw new RangeError('end < start');

	  // Fill 0 bytes; we're done
	  if (end === start) return;
	  if (this.length === 0) return;

	  if (start < 0 || start >= this.length) throw new RangeError('start out of bounds');
	  if (end < 0 || end > this.length) throw new RangeError('end out of bounds');

	  var i;
	  if (typeof value === 'number') {
	    for (i = start; i < end; i++) {
	      this[i] = value;
	    }
	  } else {
	    var bytes = utf8ToBytes(value.toString());
	    var len = bytes.length;
	    for (i = start; i < end; i++) {
	      this[i] = bytes[i % len];
	    }
	  }

	  return this;
	};

	/**
	 * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
	 * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
	 */
	Buffer.prototype.toArrayBuffer = function toArrayBuffer() {
	  if (typeof Uint8Array !== 'undefined') {
	    if (Buffer.TYPED_ARRAY_SUPPORT) {
	      return new Buffer(this).buffer;
	    } else {
	      var buf = new Uint8Array(this.length);
	      for (var i = 0, len = buf.length; i < len; i += 1) {
	        buf[i] = this[i];
	      }
	      return buf.buffer;
	    }
	  } else {
	    throw new TypeError('Buffer.toArrayBuffer not supported in this browser');
	  }
	};

	// HELPER FUNCTIONS
	// ================

	var BP = Buffer.prototype;

	/**
	 * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
	 */
	Buffer._augment = function _augment(arr) {
	  arr.constructor = Buffer;
	  arr._isBuffer = true;

	  // save reference to original Uint8Array set method before overwriting
	  arr._set = arr.set;

	  // deprecated
	  arr.get = BP.get;
	  arr.set = BP.set;

	  arr.write = BP.write;
	  arr.toString = BP.toString;
	  arr.toLocaleString = BP.toString;
	  arr.toJSON = BP.toJSON;
	  arr.equals = BP.equals;
	  arr.compare = BP.compare;
	  arr.indexOf = BP.indexOf;
	  arr.copy = BP.copy;
	  arr.slice = BP.slice;
	  arr.readUIntLE = BP.readUIntLE;
	  arr.readUIntBE = BP.readUIntBE;
	  arr.readUInt8 = BP.readUInt8;
	  arr.readUInt16LE = BP.readUInt16LE;
	  arr.readUInt16BE = BP.readUInt16BE;
	  arr.readUInt32LE = BP.readUInt32LE;
	  arr.readUInt32BE = BP.readUInt32BE;
	  arr.readIntLE = BP.readIntLE;
	  arr.readIntBE = BP.readIntBE;
	  arr.readInt8 = BP.readInt8;
	  arr.readInt16LE = BP.readInt16LE;
	  arr.readInt16BE = BP.readInt16BE;
	  arr.readInt32LE = BP.readInt32LE;
	  arr.readInt32BE = BP.readInt32BE;
	  arr.readFloatLE = BP.readFloatLE;
	  arr.readFloatBE = BP.readFloatBE;
	  arr.readDoubleLE = BP.readDoubleLE;
	  arr.readDoubleBE = BP.readDoubleBE;
	  arr.writeUInt8 = BP.writeUInt8;
	  arr.writeUIntLE = BP.writeUIntLE;
	  arr.writeUIntBE = BP.writeUIntBE;
	  arr.writeUInt16LE = BP.writeUInt16LE;
	  arr.writeUInt16BE = BP.writeUInt16BE;
	  arr.writeUInt32LE = BP.writeUInt32LE;
	  arr.writeUInt32BE = BP.writeUInt32BE;
	  arr.writeIntLE = BP.writeIntLE;
	  arr.writeIntBE = BP.writeIntBE;
	  arr.writeInt8 = BP.writeInt8;
	  arr.writeInt16LE = BP.writeInt16LE;
	  arr.writeInt16BE = BP.writeInt16BE;
	  arr.writeInt32LE = BP.writeInt32LE;
	  arr.writeInt32BE = BP.writeInt32BE;
	  arr.writeFloatLE = BP.writeFloatLE;
	  arr.writeFloatBE = BP.writeFloatBE;
	  arr.writeDoubleLE = BP.writeDoubleLE;
	  arr.writeDoubleBE = BP.writeDoubleBE;
	  arr.fill = BP.fill;
	  arr.inspect = BP.inspect;
	  arr.toArrayBuffer = BP.toArrayBuffer;

	  return arr;
	};

	var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

	function base64clean(str) {
	  // Node strips out invalid characters like \n and \t from the string, base64-js does not
	  str = stringtrim(str).replace(INVALID_BASE64_RE, '');
	  // Node converts strings with length < 2 to ''
	  if (str.length < 2) return '';
	  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
	  while (str.length % 4 !== 0) {
	    str = str + '=';
	  }
	  return str;
	}

	function stringtrim(str) {
	  if (str.trim) return str.trim();
	  return str.replace(/^\s+|\s+$/g, '');
	}

	function toHex(n) {
	  if (n < 16) return '0' + n.toString(16);
	  return n.toString(16);
	}

	function utf8ToBytes(string, units) {
	  units = units || Infinity;
	  var codePoint;
	  var length = string.length;
	  var leadSurrogate = null;
	  var bytes = [];

	  for (var i = 0; i < length; i++) {
	    codePoint = string.charCodeAt(i);

	    // is surrogate component
	    if (codePoint > 0xD7FF && codePoint < 0xE000) {
	      // last char was a lead
	      if (!leadSurrogate) {
	        // no lead yet
	        if (codePoint > 0xDBFF) {
	          // unexpected trail
	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
	          continue;
	        } else if (i + 1 === length) {
	          // unpaired lead
	          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
	          continue;
	        }

	        // valid lead
	        leadSurrogate = codePoint;

	        continue;
	      }

	      // 2 leads in a row
	      if (codePoint < 0xDC00) {
	        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
	        leadSurrogate = codePoint;
	        continue;
	      }

	      // valid surrogate pair
	      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
	    } else if (leadSurrogate) {
	      // valid bmp char, but last char was a lead
	      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
	    }

	    leadSurrogate = null;

	    // encode utf8
	    if (codePoint < 0x80) {
	      if ((units -= 1) < 0) break;
	      bytes.push(codePoint);
	    } else if (codePoint < 0x800) {
	      if ((units -= 2) < 0) break;
	      bytes.push(codePoint >> 0x6 | 0xC0, codePoint & 0x3F | 0x80);
	    } else if (codePoint < 0x10000) {
	      if ((units -= 3) < 0) break;
	      bytes.push(codePoint >> 0xC | 0xE0, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
	    } else if (codePoint < 0x110000) {
	      if ((units -= 4) < 0) break;
	      bytes.push(codePoint >> 0x12 | 0xF0, codePoint >> 0xC & 0x3F | 0x80, codePoint >> 0x6 & 0x3F | 0x80, codePoint & 0x3F | 0x80);
	    } else {
	      throw new Error('Invalid code point');
	    }
	  }

	  return bytes;
	}

	function asciiToBytes(str) {
	  var byteArray = [];
	  for (var i = 0; i < str.length; i++) {
	    // Node's code seems to be doing this and not & 0x7F..
	    byteArray.push(str.charCodeAt(i) & 0xFF);
	  }
	  return byteArray;
	}

	function utf16leToBytes(str, units) {
	  var c, hi, lo;
	  var byteArray = [];
	  for (var i = 0; i < str.length; i++) {
	    if ((units -= 2) < 0) break;

	    c = str.charCodeAt(i);
	    hi = c >> 8;
	    lo = c % 256;
	    byteArray.push(lo);
	    byteArray.push(hi);
	  }

	  return byteArray;
	}

	function base64ToBytes(str) {
	  return base64.toByteArray(base64clean(str));
	}

	function blitBuffer(src, dst, offset, length) {
	  for (var i = 0; i < length; i++) {
	    if (i + offset >= dst.length || i >= src.length) break;
	    dst[i + offset] = src[i];
	  }
	  return i;
	}
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer, (function() { return this; }())))

/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

	;(function (exports) {
		'use strict';

		var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;

		var PLUS = '+'.charCodeAt(0);
		var SLASH = '/'.charCodeAt(0);
		var NUMBER = '0'.charCodeAt(0);
		var LOWER = 'a'.charCodeAt(0);
		var UPPER = 'A'.charCodeAt(0);
		var PLUS_URL_SAFE = '-'.charCodeAt(0);
		var SLASH_URL_SAFE = '_'.charCodeAt(0);

		function decode(elt) {
			var code = elt.charCodeAt(0);
			if (code === PLUS || code === PLUS_URL_SAFE) return 62; // '+'
			if (code === SLASH || code === SLASH_URL_SAFE) return 63; // '/'
			if (code < NUMBER) return -1; //no match
			if (code < NUMBER + 10) return code - NUMBER + 26 + 26;
			if (code < UPPER + 26) return code - UPPER;
			if (code < LOWER + 26) return code - LOWER + 26;
		}

		function b64ToByteArray(b64) {
			var i, j, l, tmp, placeHolders, arr;

			if (b64.length % 4 > 0) {
				throw new Error('Invalid string. Length must be a multiple of 4');
			}

			// the number of equal signs (place holders)
			// if there are two placeholders, than the two characters before it
			// represent one byte
			// if there is only one, then the three characters before it represent 2 bytes
			// this is just a cheap hack to not do indexOf twice
			var len = b64.length;
			placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0;

			// base64 is 4/3 + up to two characters of the original data
			arr = new Arr(b64.length * 3 / 4 - placeHolders);

			// if there are placeholders, only get up to the last complete 4 chars
			l = placeHolders > 0 ? b64.length - 4 : b64.length;

			var L = 0;

			function push(v) {
				arr[L++] = v;
			}

			for (i = 0, j = 0; i < l; i += 4, j += 3) {
				tmp = decode(b64.charAt(i)) << 18 | decode(b64.charAt(i + 1)) << 12 | decode(b64.charAt(i + 2)) << 6 | decode(b64.charAt(i + 3));
				push((tmp & 0xFF0000) >> 16);
				push((tmp & 0xFF00) >> 8);
				push(tmp & 0xFF);
			}

			if (placeHolders === 2) {
				tmp = decode(b64.charAt(i)) << 2 | decode(b64.charAt(i + 1)) >> 4;
				push(tmp & 0xFF);
			} else if (placeHolders === 1) {
				tmp = decode(b64.charAt(i)) << 10 | decode(b64.charAt(i + 1)) << 4 | decode(b64.charAt(i + 2)) >> 2;
				push(tmp >> 8 & 0xFF);
				push(tmp & 0xFF);
			}

			return arr;
		}

		function uint8ToBase64(uint8) {
			var i,
			    extraBytes = uint8.length % 3,
			    // if we have 1 byte left, pad 2 bytes
			output = "",
			    temp,
			    length;

			function encode(num) {
				return lookup.charAt(num);
			}

			function tripletToBase64(num) {
				return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F);
			}

			// go through the array every three bytes, we'll deal with trailing stuff later
			for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
				temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
				output += tripletToBase64(temp);
			}

			// pad the end with zeros, but make sure to not forget the extra bytes
			switch (extraBytes) {
				case 1:
					temp = uint8[uint8.length - 1];
					output += encode(temp >> 2);
					output += encode(temp << 4 & 0x3F);
					output += '==';
					break;
				case 2:
					temp = (uint8[uint8.length - 2] << 8) + uint8[uint8.length - 1];
					output += encode(temp >> 10);
					output += encode(temp >> 4 & 0x3F);
					output += encode(temp << 2 & 0x3F);
					output += '=';
					break;
			}

			return output;
		}

		exports.toByteArray = b64ToByteArray;
		exports.fromByteArray = uint8ToBase64;
	})( false ? undefined.base64js = {} : exports);

/***/ },
/* 23 */
/***/ function(module, exports) {

	"use strict";

	exports.read = function (buffer, offset, isLE, mLen, nBytes) {
	  var e, m;
	  var eLen = nBytes * 8 - mLen - 1;
	  var eMax = (1 << eLen) - 1;
	  var eBias = eMax >> 1;
	  var nBits = -7;
	  var i = isLE ? nBytes - 1 : 0;
	  var d = isLE ? -1 : 1;
	  var s = buffer[offset + i];

	  i += d;

	  e = s & (1 << -nBits) - 1;
	  s >>= -nBits;
	  nBits += eLen;
	  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}

	  m = e & (1 << -nBits) - 1;
	  e >>= -nBits;
	  nBits += mLen;
	  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}

	  if (e === 0) {
	    e = 1 - eBias;
	  } else if (e === eMax) {
	    return m ? NaN : (s ? -1 : 1) * Infinity;
	  } else {
	    m = m + Math.pow(2, mLen);
	    e = e - eBias;
	  }
	  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
	};

	exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
	  var e, m, c;
	  var eLen = nBytes * 8 - mLen - 1;
	  var eMax = (1 << eLen) - 1;
	  var eBias = eMax >> 1;
	  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
	  var i = isLE ? 0 : nBytes - 1;
	  var d = isLE ? 1 : -1;
	  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;

	  value = Math.abs(value);

	  if (isNaN(value) || value === Infinity) {
	    m = isNaN(value) ? 1 : 0;
	    e = eMax;
	  } else {
	    e = Math.floor(Math.log(value) / Math.LN2);
	    if (value * (c = Math.pow(2, -e)) < 1) {
	      e--;
	      c *= 2;
	    }
	    if (e + eBias >= 1) {
	      value += rt / c;
	    } else {
	      value += rt * Math.pow(2, 1 - eBias);
	    }
	    if (value * c >= 2) {
	      e++;
	      c /= 2;
	    }

	    if (e + eBias >= eMax) {
	      m = 0;
	      e = eMax;
	    } else if (e + eBias >= 1) {
	      m = (value * c - 1) * Math.pow(2, mLen);
	      e = e + eBias;
	    } else {
	      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
	      e = 0;
	    }
	  }

	  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

	  e = e << mLen | m;
	  eLen += mLen;
	  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

	  buffer[offset + i - d] |= s * 128;
	};

/***/ },
/* 24 */
/***/ function(module, exports) {

	'use strict';

	var toString = {}.toString;

	module.exports = Array.isArray || function (arr) {
	  return toString.call(arr) == '[object Array]';
	};

/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global, Buffer) {'use strict';

	(function () {
	  var g = ('undefined' === typeof window ? global : window) || {};
	  _crypto = g.crypto || g.msCrypto || __webpack_require__(26);
	  module.exports = function (size) {
	    // Modern Browsers
	    if (_crypto.getRandomValues) {
	      var bytes = new Buffer(size); //in browserify, this is an extended Uint8Array
	      /* This will not work in older browsers.
	       * See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
	       */

	      _crypto.getRandomValues(bytes);
	      return bytes;
	    } else if (_crypto.randomBytes) {
	      return _crypto.randomBytes(size);
	    } else throw new Error('secure random number generation not supported by this browser\n' + 'use chrome, FireFox or Internet Explorer 11');
	  };
	})();
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(21).Buffer))

/***/ },
/* 26 */
/***/ function(module, exports) {

	/* (ignored) */

/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';

	var createHash = __webpack_require__(28);

	var md5 = toConstructor(__webpack_require__(36));
	var rmd160 = toConstructor(__webpack_require__(38));

	function toConstructor(fn) {
	  return function () {
	    var buffers = [];
	    var m = {
	      update: function update(data, enc) {
	        if (!Buffer.isBuffer(data)) data = new Buffer(data, enc);
	        buffers.push(data);
	        return this;
	      },
	      digest: function digest(enc) {
	        var buf = Buffer.concat(buffers);
	        var r = fn(buf);
	        buffers = null;
	        return enc ? r.toString(enc) : r;
	      }
	    };
	    return m;
	  };
	}

	module.exports = function (alg) {
	  if ('md5' === alg) return new md5();
	  if ('rmd160' === alg) return new rmd160();
	  return createHash(alg);
	};
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var _exports = module.exports = function (alg) {
	  var Alg = _exports[alg];
	  if (!Alg) throw new Error(alg + ' is not supported (we accept pull requests)');
	  return new Alg();
	};

	var Buffer = __webpack_require__(21).Buffer;
	var Hash = __webpack_require__(29)(Buffer);

	_exports.sha1 = __webpack_require__(30)(Buffer, Hash);
	_exports.sha256 = __webpack_require__(34)(Buffer, Hash);
	_exports.sha512 = __webpack_require__(35)(Buffer, Hash);

/***/ },
/* 29 */
/***/ function(module, exports) {

	"use strict";

	module.exports = function (Buffer) {

	  //prototype class for hash functions
	  function Hash(blockSize, finalSize) {
	    this._block = new Buffer(blockSize); //new Uint32Array(blockSize/4)
	    this._finalSize = finalSize;
	    this._blockSize = blockSize;
	    this._len = 0;
	    this._s = 0;
	  }

	  Hash.prototype.init = function () {
	    this._s = 0;
	    this._len = 0;
	  };

	  Hash.prototype.update = function (data, enc) {
	    if ("string" === typeof data) {
	      enc = enc || "utf8";
	      data = new Buffer(data, enc);
	    }

	    var l = this._len += data.length;
	    var s = this._s = this._s || 0;
	    var f = 0;
	    var buffer = this._block;

	    while (s < l) {
	      var t = Math.min(data.length, f + this._blockSize - s % this._blockSize);
	      var ch = t - f;

	      for (var i = 0; i < ch; i++) {
	        buffer[s % this._blockSize + i] = data[i + f];
	      }

	      s += ch;
	      f += ch;

	      if (s % this._blockSize === 0) {
	        this._update(buffer);
	      }
	    }
	    this._s = s;

	    return this;
	  };

	  Hash.prototype.digest = function (enc) {
	    // Suppose the length of the message M, in bits, is l
	    var l = this._len * 8;

	    // Append the bit 1 to the end of the message
	    this._block[this._len % this._blockSize] = 0x80;

	    // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
	    this._block.fill(0, this._len % this._blockSize + 1);

	    if (l % (this._blockSize * 8) >= this._finalSize * 8) {
	      this._update(this._block);
	      this._block.fill(0);
	    }

	    // to this append the block which is equal to the number l written in binary
	    // TODO: handle case where l is > Math.pow(2, 29)
	    this._block.writeInt32BE(l, this._blockSize - 4);

	    var hash = this._update(this._block) || this._hash();

	    return enc ? hash.toString(enc) : hash;
	  };

	  Hash.prototype._update = function () {
	    throw new Error('_update must be implemented by subclass');
	  };

	  return Hash;
	};

/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	/*
	 * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
	 * in FIPS PUB 180-1
	 * Version 2.1a Copyright Paul Johnston 2000 - 2002.
	 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
	 * Distributed under the BSD License
	 * See http://pajhome.org.uk/crypt/md5 for details.
	 */

	var inherits = __webpack_require__(31).inherits;

	module.exports = function (Buffer, Hash) {

	  var A = 0 | 0;
	  var B = 4 | 0;
	  var C = 8 | 0;
	  var D = 12 | 0;
	  var E = 16 | 0;

	  var W = new (typeof Int32Array === 'undefined' ? Array : Int32Array)(80);

	  var POOL = [];

	  function Sha1() {
	    if (POOL.length) return POOL.pop().init();

	    if (!(this instanceof Sha1)) return new Sha1();
	    this._w = W;
	    Hash.call(this, 16 * 4, 14 * 4);

	    this._h = null;
	    this.init();
	  }

	  inherits(Sha1, Hash);

	  Sha1.prototype.init = function () {
	    this._a = 0x67452301;
	    this._b = 0xefcdab89;
	    this._c = 0x98badcfe;
	    this._d = 0x10325476;
	    this._e = 0xc3d2e1f0;

	    Hash.prototype.init.call(this);
	    return this;
	  };

	  Sha1.prototype._POOL = POOL;
	  Sha1.prototype._update = function (X) {

	    var a, b, c, d, e, _a, _b, _c, _d, _e;

	    a = _a = this._a;
	    b = _b = this._b;
	    c = _c = this._c;
	    d = _d = this._d;
	    e = _e = this._e;

	    var w = this._w;

	    for (var j = 0; j < 80; j++) {
	      var W = w[j] = j < 16 ? X.readInt32BE(j * 4) : rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1);

	      var t = add(add(rol(a, 5), sha1_ft(j, b, c, d)), add(add(e, W), sha1_kt(j)));

	      e = d;
	      d = c;
	      c = rol(b, 30);
	      b = a;
	      a = t;
	    }

	    this._a = add(a, _a);
	    this._b = add(b, _b);
	    this._c = add(c, _c);
	    this._d = add(d, _d);
	    this._e = add(e, _e);
	  };

	  Sha1.prototype._hash = function () {
	    if (POOL.length < 100) POOL.push(this);
	    var H = new Buffer(20);
	    //console.log(this._a|0, this._b|0, this._c|0, this._d|0, this._e|0)
	    H.writeInt32BE(this._a | 0, A);
	    H.writeInt32BE(this._b | 0, B);
	    H.writeInt32BE(this._c | 0, C);
	    H.writeInt32BE(this._d | 0, D);
	    H.writeInt32BE(this._e | 0, E);
	    return H;
	  };

	  /*
	   * Perform the appropriate triplet combination function for the current
	   * iteration
	   */
	  function sha1_ft(t, b, c, d) {
	    if (t < 20) return b & c | ~b & d;
	    if (t < 40) return b ^ c ^ d;
	    if (t < 60) return b & c | b & d | c & d;
	    return b ^ c ^ d;
	  }

	  /*
	   * Determine the appropriate additive constant for the current iteration
	   */
	  function sha1_kt(t) {
	    return t < 20 ? 1518500249 : t < 40 ? 1859775393 : t < 60 ? -1894007588 : -899497514;
	  }

	  /*
	   * Add integers, wrapping at 2^32. This uses 16-bit operations internally
	   * to work around bugs in some JS interpreters.
	   * //dominictarr: this is 10 years old, so maybe this can be dropped?)
	   *
	   */
	  function add(x, y) {
	    return x + y | 0;
	    //lets see how this goes on testling.
	    //  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
	    //  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
	    //  return (msw << 16) | (lsw & 0xFFFF);
	  }

	  /*
	   * Bitwise rotate a 32-bit number to the left.
	   */
	  function rol(num, cnt) {
	    return num << cnt | num >>> 32 - cnt;
	  }

	  return Sha1;
	};

/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global, process) {'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	// Copyright Joyent, Inc. and other Node contributors.
	//
	// Permission is hereby granted, free of charge, to any person obtaining a
	// copy of this software and associated documentation files (the
	// "Software"), to deal in the Software without restriction, including
	// without limitation the rights to use, copy, modify, merge, publish,
	// distribute, sublicense, and/or sell copies of the Software, and to permit
	// persons to whom the Software is furnished to do so, subject to the
	// following conditions:
	//
	// The above copyright notice and this permission notice shall be included
	// in all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	// USE OR OTHER DEALINGS IN THE SOFTWARE.

	var formatRegExp = /%[sdj%]/g;
	exports.format = function (f) {
	  if (!isString(f)) {
	    var objects = [];
	    for (var i = 0; i < arguments.length; i++) {
	      objects.push(inspect(arguments[i]));
	    }
	    return objects.join(' ');
	  }

	  var i = 1;
	  var args = arguments;
	  var len = args.length;
	  var str = String(f).replace(formatRegExp, function (x) {
	    if (x === '%%') return '%';
	    if (i >= len) return x;
	    switch (x) {
	      case '%s':
	        return String(args[i++]);
	      case '%d':
	        return Number(args[i++]);
	      case '%j':
	        try {
	          return JSON.stringify(args[i++]);
	        } catch (_) {
	          return '[Circular]';
	        }
	      default:
	        return x;
	    }
	  });
	  for (var x = args[i]; i < len; x = args[++i]) {
	    if (isNull(x) || !isObject(x)) {
	      str += ' ' + x;
	    } else {
	      str += ' ' + inspect(x);
	    }
	  }
	  return str;
	};

	// Mark that a method should not be used.
	// Returns a modified function which warns once by default.
	// If --no-deprecation is set, then it is a no-op.
	exports.deprecate = function (fn, msg) {
	  // Allow for deprecating things in the process of starting up.
	  if (isUndefined(global.process)) {
	    return function () {
	      return exports.deprecate(fn, msg).apply(this, arguments);
	    };
	  }

	  if (process.noDeprecation === true) {
	    return fn;
	  }

	  var warned = false;
	  function deprecated() {
	    if (!warned) {
	      if (process.throwDeprecation) {
	        throw new Error(msg);
	      } else if (process.traceDeprecation) {
	        console.trace(msg);
	      } else {
	        console.error(msg);
	      }
	      warned = true;
	    }
	    return fn.apply(this, arguments);
	  }

	  return deprecated;
	};

	var debugs = {};
	var debugEnviron;
	exports.debuglog = function (set) {
	  if (isUndefined(debugEnviron)) debugEnviron = process.env.NODE_DEBUG || '';
	  set = set.toUpperCase();
	  if (!debugs[set]) {
	    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
	      var pid = process.pid;
	      debugs[set] = function () {
	        var msg = exports.format.apply(exports, arguments);
	        console.error('%s %d: %s', set, pid, msg);
	      };
	    } else {
	      debugs[set] = function () {};
	    }
	  }
	  return debugs[set];
	};

	/**
	 * Echos the value of a value. Trys to print the value out
	 * in the best way possible given the different types.
	 *
	 * @param {Object} obj The object to print out.
	 * @param {Object} opts Optional options object that alters the output.
	 */
	/* legacy: obj, showHidden, depth, colors*/
	function inspect(obj, opts) {
	  // default options
	  var ctx = {
	    seen: [],
	    stylize: stylizeNoColor
	  };
	  // legacy...
	  if (arguments.length >= 3) ctx.depth = arguments[2];
	  if (arguments.length >= 4) ctx.colors = arguments[3];
	  if (isBoolean(opts)) {
	    // legacy...
	    ctx.showHidden = opts;
	  } else if (opts) {
	    // got an "options" object
	    exports._extend(ctx, opts);
	  }
	  // set default options
	  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
	  if (isUndefined(ctx.depth)) ctx.depth = 2;
	  if (isUndefined(ctx.colors)) ctx.colors = false;
	  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
	  if (ctx.colors) ctx.stylize = stylizeWithColor;
	  return formatValue(ctx, obj, ctx.depth);
	}
	exports.inspect = inspect;

	// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
	inspect.colors = {
	  'bold': [1, 22],
	  'italic': [3, 23],
	  'underline': [4, 24],
	  'inverse': [7, 27],
	  'white': [37, 39],
	  'grey': [90, 39],
	  'black': [30, 39],
	  'blue': [34, 39],
	  'cyan': [36, 39],
	  'green': [32, 39],
	  'magenta': [35, 39],
	  'red': [31, 39],
	  'yellow': [33, 39]
	};

	// Don't use 'blue' not visible on cmd.exe
	inspect.styles = {
	  'special': 'cyan',
	  'number': 'yellow',
	  'boolean': 'yellow',
	  'undefined': 'grey',
	  'null': 'bold',
	  'string': 'green',
	  'date': 'magenta',
	  // "name": intentionally not styling
	  'regexp': 'red'
	};

	function stylizeWithColor(str, styleType) {
	  var style = inspect.styles[styleType];

	  if (style) {
	    return '\u001b[' + inspect.colors[style][0] + 'm' + str + '\u001b[' + inspect.colors[style][1] + 'm';
	  } else {
	    return str;
	  }
	}

	function stylizeNoColor(str, styleType) {
	  return str;
	}

	function arrayToHash(array) {
	  var hash = {};

	  array.forEach(function (val, idx) {
	    hash[val] = true;
	  });

	  return hash;
	}

	function formatValue(ctx, value, recurseTimes) {
	  // Provide a hook for user-specified inspect functions.
	  // Check that value is an object with an inspect function on it
	  if (ctx.customInspect && value && isFunction(value.inspect) &&
	  // Filter out the util module, it's inspect function is special
	  value.inspect !== exports.inspect &&
	  // Also filter out any prototype objects using the circular check.
	  !(value.constructor && value.constructor.prototype === value)) {
	    var ret = value.inspect(recurseTimes, ctx);
	    if (!isString(ret)) {
	      ret = formatValue(ctx, ret, recurseTimes);
	    }
	    return ret;
	  }

	  // Primitive types cannot have properties
	  var primitive = formatPrimitive(ctx, value);
	  if (primitive) {
	    return primitive;
	  }

	  // Look up the keys of the object.
	  var keys = Object.keys(value);
	  var visibleKeys = arrayToHash(keys);

	  if (ctx.showHidden) {
	    keys = Object.getOwnPropertyNames(value);
	  }

	  // IE doesn't make error fields non-enumerable
	  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
	  if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
	    return formatError(value);
	  }

	  // Some type of object without properties can be shortcutted.
	  if (keys.length === 0) {
	    if (isFunction(value)) {
	      var name = value.name ? ': ' + value.name : '';
	      return ctx.stylize('[Function' + name + ']', 'special');
	    }
	    if (isRegExp(value)) {
	      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
	    }
	    if (isDate(value)) {
	      return ctx.stylize(Date.prototype.toString.call(value), 'date');
	    }
	    if (isError(value)) {
	      return formatError(value);
	    }
	  }

	  var base = '',
	      array = false,
	      braces = ['{', '}'];

	  // Make Array say that they are Array
	  if (isArray(value)) {
	    array = true;
	    braces = ['[', ']'];
	  }

	  // Make functions say that they are functions
	  if (isFunction(value)) {
	    var n = value.name ? ': ' + value.name : '';
	    base = ' [Function' + n + ']';
	  }

	  // Make RegExps say that they are RegExps
	  if (isRegExp(value)) {
	    base = ' ' + RegExp.prototype.toString.call(value);
	  }

	  // Make dates with properties first say the date
	  if (isDate(value)) {
	    base = ' ' + Date.prototype.toUTCString.call(value);
	  }

	  // Make error with message first say the error
	  if (isError(value)) {
	    base = ' ' + formatError(value);
	  }

	  if (keys.length === 0 && (!array || value.length == 0)) {
	    return braces[0] + base + braces[1];
	  }

	  if (recurseTimes < 0) {
	    if (isRegExp(value)) {
	      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
	    } else {
	      return ctx.stylize('[Object]', 'special');
	    }
	  }

	  ctx.seen.push(value);

	  var output;
	  if (array) {
	    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
	  } else {
	    output = keys.map(function (key) {
	      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
	    });
	  }

	  ctx.seen.pop();

	  return reduceToSingleString(output, base, braces);
	}

	function formatPrimitive(ctx, value) {
	  if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
	  if (isString(value)) {
	    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
	    return ctx.stylize(simple, 'string');
	  }
	  if (isNumber(value)) return ctx.stylize('' + value, 'number');
	  if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
	  // For some reason typeof null is "object", so special case here.
	  if (isNull(value)) return ctx.stylize('null', 'null');
	}

	function formatError(value) {
	  return '[' + Error.prototype.toString.call(value) + ']';
	}

	function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
	  var output = [];
	  for (var i = 0, l = value.length; i < l; ++i) {
	    if (hasOwnProperty(value, String(i))) {
	      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
	    } else {
	      output.push('');
	    }
	  }
	  keys.forEach(function (key) {
	    if (!key.match(/^\d+$/)) {
	      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
	    }
	  });
	  return output;
	}

	function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
	  var name, str, desc;
	  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
	  if (desc.get) {
	    if (desc.set) {
	      str = ctx.stylize('[Getter/Setter]', 'special');
	    } else {
	      str = ctx.stylize('[Getter]', 'special');
	    }
	  } else {
	    if (desc.set) {
	      str = ctx.stylize('[Setter]', 'special');
	    }
	  }
	  if (!hasOwnProperty(visibleKeys, key)) {
	    name = '[' + key + ']';
	  }
	  if (!str) {
	    if (ctx.seen.indexOf(desc.value) < 0) {
	      if (isNull(recurseTimes)) {
	        str = formatValue(ctx, desc.value, null);
	      } else {
	        str = formatValue(ctx, desc.value, recurseTimes - 1);
	      }
	      if (str.indexOf('\n') > -1) {
	        if (array) {
	          str = str.split('\n').map(function (line) {
	            return '  ' + line;
	          }).join('\n').substr(2);
	        } else {
	          str = '\n' + str.split('\n').map(function (line) {
	            return '   ' + line;
	          }).join('\n');
	        }
	      }
	    } else {
	      str = ctx.stylize('[Circular]', 'special');
	    }
	  }
	  if (isUndefined(name)) {
	    if (array && key.match(/^\d+$/)) {
	      return str;
	    }
	    name = JSON.stringify('' + key);
	    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
	      name = name.substr(1, name.length - 2);
	      name = ctx.stylize(name, 'name');
	    } else {
	      name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
	      name = ctx.stylize(name, 'string');
	    }
	  }

	  return name + ': ' + str;
	}

	function reduceToSingleString(output, base, braces) {
	  var numLinesEst = 0;
	  var length = output.reduce(function (prev, cur) {
	    numLinesEst++;
	    if (cur.indexOf('\n') >= 0) numLinesEst++;
	    return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
	  }, 0);

	  if (length > 60) {
	    return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
	  }

	  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
	}

	// NOTE: These type checking functions intentionally don't use `instanceof`
	// because it is fragile and can be easily faked with `Object.create()`.
	function isArray(ar) {
	  return Array.isArray(ar);
	}
	exports.isArray = isArray;

	function isBoolean(arg) {
	  return typeof arg === 'boolean';
	}
	exports.isBoolean = isBoolean;

	function isNull(arg) {
	  return arg === null;
	}
	exports.isNull = isNull;

	function isNullOrUndefined(arg) {
	  return arg == null;
	}
	exports.isNullOrUndefined = isNullOrUndefined;

	function isNumber(arg) {
	  return typeof arg === 'number';
	}
	exports.isNumber = isNumber;

	function isString(arg) {
	  return typeof arg === 'string';
	}
	exports.isString = isString;

	function isSymbol(arg) {
	  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol';
	}
	exports.isSymbol = isSymbol;

	function isUndefined(arg) {
	  return arg === void 0;
	}
	exports.isUndefined = isUndefined;

	function isRegExp(re) {
	  return isObject(re) && objectToString(re) === '[object RegExp]';
	}
	exports.isRegExp = isRegExp;

	function isObject(arg) {
	  return (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && arg !== null;
	}
	exports.isObject = isObject;

	function isDate(d) {
	  return isObject(d) && objectToString(d) === '[object Date]';
	}
	exports.isDate = isDate;

	function isError(e) {
	  return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
	}
	exports.isError = isError;

	function isFunction(arg) {
	  return typeof arg === 'function';
	}
	exports.isFunction = isFunction;

	function isPrimitive(arg) {
	  return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'symbol' || // ES6 symbol
	  typeof arg === 'undefined';
	}
	exports.isPrimitive = isPrimitive;

	exports.isBuffer = __webpack_require__(32);

	function objectToString(o) {
	  return Object.prototype.toString.call(o);
	}

	function pad(n) {
	  return n < 10 ? '0' + n.toString(10) : n.toString(10);
	}

	var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

	// 26 Feb 16:19:34
	function timestamp() {
	  var d = new Date();
	  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');
	  return [d.getDate(), months[d.getMonth()], time].join(' ');
	}

	// log is just a thin wrapper to console.log that prepends a timestamp
	exports.log = function () {
	  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
	};

	/**
	 * Inherit the prototype methods from one constructor into another.
	 *
	 * The Function.prototype.inherits from lang.js rewritten as a standalone
	 * function (not on Function.prototype). NOTE: If this file is to be loaded
	 * during bootstrapping this function needs to be rewritten using some native
	 * functions as prototype setup using normal JavaScript does not work as
	 * expected during bootstrapping (see mirror.js in r114903).
	 *
	 * @param {function} ctor Constructor function which needs to inherit the
	 *     prototype.
	 * @param {function} superCtor Constructor function to inherit prototype from.
	 */
	exports.inherits = __webpack_require__(33);

	exports._extend = function (origin, add) {
	  // Don't do anything if add isn't an object
	  if (!add || !isObject(add)) return origin;

	  var keys = Object.keys(add);
	  var i = keys.length;
	  while (i--) {
	    origin[keys[i]] = add[keys[i]];
	  }
	  return origin;
	};

	function hasOwnProperty(obj, prop) {
	  return Object.prototype.hasOwnProperty.call(obj, prop);
	}
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(3)))

/***/ },
/* 32 */
/***/ function(module, exports) {

	'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	module.exports = function isBuffer(arg) {
	  return arg && (typeof arg === 'undefined' ? 'undefined' : _typeof(arg)) === 'object' && typeof arg.copy === 'function' && typeof arg.fill === 'function' && typeof arg.readUInt8 === 'function';
	};

/***/ },
/* 33 */
/***/ function(module, exports) {

	'use strict';

	if (typeof Object.create === 'function') {
	  // implementation from standard node.js 'util' module
	  module.exports = function inherits(ctor, superCtor) {
	    ctor.super_ = superCtor;
	    ctor.prototype = Object.create(superCtor.prototype, {
	      constructor: {
	        value: ctor,
	        enumerable: false,
	        writable: true,
	        configurable: true
	      }
	    });
	  };
	} else {
	  // old school shim for old browsers
	  module.exports = function inherits(ctor, superCtor) {
	    ctor.super_ = superCtor;
	    var TempCtor = function TempCtor() {};
	    TempCtor.prototype = superCtor.prototype;
	    ctor.prototype = new TempCtor();
	    ctor.prototype.constructor = ctor;
	  };
	}

/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	/**
	 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
	 * in FIPS 180-2
	 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
	 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
	 *
	 */

	var inherits = __webpack_require__(31).inherits;

	module.exports = function (Buffer, Hash) {

	  var K = [0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2];

	  var W = new Array(64);

	  function Sha256() {
	    this.init();

	    this._w = W; //new Array(64)

	    Hash.call(this, 16 * 4, 14 * 4);
	  }

	  inherits(Sha256, Hash);

	  Sha256.prototype.init = function () {

	    this._a = 0x6a09e667 | 0;
	    this._b = 0xbb67ae85 | 0;
	    this._c = 0x3c6ef372 | 0;
	    this._d = 0xa54ff53a | 0;
	    this._e = 0x510e527f | 0;
	    this._f = 0x9b05688c | 0;
	    this._g = 0x1f83d9ab | 0;
	    this._h = 0x5be0cd19 | 0;

	    this._len = this._s = 0;

	    return this;
	  };

	  function S(X, n) {
	    return X >>> n | X << 32 - n;
	  }

	  function R(X, n) {
	    return X >>> n;
	  }

	  function Ch(x, y, z) {
	    return x & y ^ ~x & z;
	  }

	  function Maj(x, y, z) {
	    return x & y ^ x & z ^ y & z;
	  }

	  function Sigma0256(x) {
	    return S(x, 2) ^ S(x, 13) ^ S(x, 22);
	  }

	  function Sigma1256(x) {
	    return S(x, 6) ^ S(x, 11) ^ S(x, 25);
	  }

	  function Gamma0256(x) {
	    return S(x, 7) ^ S(x, 18) ^ R(x, 3);
	  }

	  function Gamma1256(x) {
	    return S(x, 17) ^ S(x, 19) ^ R(x, 10);
	  }

	  Sha256.prototype._update = function (M) {

	    var W = this._w;
	    var a, b, c, d, e, f, g, h;
	    var T1, T2;

	    a = this._a | 0;
	    b = this._b | 0;
	    c = this._c | 0;
	    d = this._d | 0;
	    e = this._e | 0;
	    f = this._f | 0;
	    g = this._g | 0;
	    h = this._h | 0;

	    for (var j = 0; j < 64; j++) {
	      var w = W[j] = j < 16 ? M.readInt32BE(j * 4) : Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16];

	      T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w;

	      T2 = Sigma0256(a) + Maj(a, b, c);
	      h = g;g = f;f = e;e = d + T1;d = c;c = b;b = a;a = T1 + T2;
	    }

	    this._a = a + this._a | 0;
	    this._b = b + this._b | 0;
	    this._c = c + this._c | 0;
	    this._d = d + this._d | 0;
	    this._e = e + this._e | 0;
	    this._f = f + this._f | 0;
	    this._g = g + this._g | 0;
	    this._h = h + this._h | 0;
	  };

	  Sha256.prototype._hash = function () {
	    var H = new Buffer(32);

	    H.writeInt32BE(this._a, 0);
	    H.writeInt32BE(this._b, 4);
	    H.writeInt32BE(this._c, 8);
	    H.writeInt32BE(this._d, 12);
	    H.writeInt32BE(this._e, 16);
	    H.writeInt32BE(this._f, 20);
	    H.writeInt32BE(this._g, 24);
	    H.writeInt32BE(this._h, 28);

	    return H;
	  };

	  return Sha256;
	};

/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var inherits = __webpack_require__(31).inherits;

	module.exports = function (Buffer, Hash) {
	  var K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];

	  var W = new Array(160);

	  function Sha512() {
	    this.init();
	    this._w = W;

	    Hash.call(this, 128, 112);
	  }

	  inherits(Sha512, Hash);

	  Sha512.prototype.init = function () {

	    this._a = 0x6a09e667 | 0;
	    this._b = 0xbb67ae85 | 0;
	    this._c = 0x3c6ef372 | 0;
	    this._d = 0xa54ff53a | 0;
	    this._e = 0x510e527f | 0;
	    this._f = 0x9b05688c | 0;
	    this._g = 0x1f83d9ab | 0;
	    this._h = 0x5be0cd19 | 0;

	    this._al = 0xf3bcc908 | 0;
	    this._bl = 0x84caa73b | 0;
	    this._cl = 0xfe94f82b | 0;
	    this._dl = 0x5f1d36f1 | 0;
	    this._el = 0xade682d1 | 0;
	    this._fl = 0x2b3e6c1f | 0;
	    this._gl = 0xfb41bd6b | 0;
	    this._hl = 0x137e2179 | 0;

	    this._len = this._s = 0;

	    return this;
	  };

	  function S(X, Xl, n) {
	    return X >>> n | Xl << 32 - n;
	  }

	  function Ch(x, y, z) {
	    return x & y ^ ~x & z;
	  }

	  function Maj(x, y, z) {
	    return x & y ^ x & z ^ y & z;
	  }

	  Sha512.prototype._update = function (M) {

	    var W = this._w;
	    var a, b, c, d, e, f, g, h;
	    var al, bl, cl, dl, el, fl, gl, hl;

	    a = this._a | 0;
	    b = this._b | 0;
	    c = this._c | 0;
	    d = this._d | 0;
	    e = this._e | 0;
	    f = this._f | 0;
	    g = this._g | 0;
	    h = this._h | 0;

	    al = this._al | 0;
	    bl = this._bl | 0;
	    cl = this._cl | 0;
	    dl = this._dl | 0;
	    el = this._el | 0;
	    fl = this._fl | 0;
	    gl = this._gl | 0;
	    hl = this._hl | 0;

	    for (var i = 0; i < 80; i++) {
	      var j = i * 2;

	      var Wi, Wil;

	      if (i < 16) {
	        Wi = W[j] = M.readInt32BE(j * 4);
	        Wil = W[j + 1] = M.readInt32BE(j * 4 + 4);
	      } else {
	        var x = W[j - 15 * 2];
	        var xl = W[j - 15 * 2 + 1];
	        var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ x >>> 7;
	        var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7);

	        x = W[j - 2 * 2];
	        xl = W[j - 2 * 2 + 1];
	        var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ x >>> 6;
	        var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6);

	        // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
	        var Wi7 = W[j - 7 * 2];
	        var Wi7l = W[j - 7 * 2 + 1];

	        var Wi16 = W[j - 16 * 2];
	        var Wi16l = W[j - 16 * 2 + 1];

	        Wil = gamma0l + Wi7l;
	        Wi = gamma0 + Wi7 + (Wil >>> 0 < gamma0l >>> 0 ? 1 : 0);
	        Wil = Wil + gamma1l;
	        Wi = Wi + gamma1 + (Wil >>> 0 < gamma1l >>> 0 ? 1 : 0);
	        Wil = Wil + Wi16l;
	        Wi = Wi + Wi16 + (Wil >>> 0 < Wi16l >>> 0 ? 1 : 0);

	        W[j] = Wi;
	        W[j + 1] = Wil;
	      }

	      var maj = Maj(a, b, c);
	      var majl = Maj(al, bl, cl);

	      var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7);
	      var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7);
	      var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9);
	      var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9);

	      // t1 = h + sigma1 + ch + K[i] + W[i]
	      var Ki = K[j];
	      var Kil = K[j + 1];

	      var ch = Ch(e, f, g);
	      var chl = Ch(el, fl, gl);

	      var t1l = hl + sigma1l;
	      var t1 = h + sigma1h + (t1l >>> 0 < hl >>> 0 ? 1 : 0);
	      t1l = t1l + chl;
	      t1 = t1 + ch + (t1l >>> 0 < chl >>> 0 ? 1 : 0);
	      t1l = t1l + Kil;
	      t1 = t1 + Ki + (t1l >>> 0 < Kil >>> 0 ? 1 : 0);
	      t1l = t1l + Wil;
	      t1 = t1 + Wi + (t1l >>> 0 < Wil >>> 0 ? 1 : 0);

	      // t2 = sigma0 + maj
	      var t2l = sigma0l + majl;
	      var t2 = sigma0h + maj + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0);

	      h = g;
	      hl = gl;
	      g = f;
	      gl = fl;
	      f = e;
	      fl = el;
	      el = dl + t1l | 0;
	      e = d + t1 + (el >>> 0 < dl >>> 0 ? 1 : 0) | 0;
	      d = c;
	      dl = cl;
	      c = b;
	      cl = bl;
	      b = a;
	      bl = al;
	      al = t1l + t2l | 0;
	      a = t1 + t2 + (al >>> 0 < t1l >>> 0 ? 1 : 0) | 0;
	    }

	    this._al = this._al + al | 0;
	    this._bl = this._bl + bl | 0;
	    this._cl = this._cl + cl | 0;
	    this._dl = this._dl + dl | 0;
	    this._el = this._el + el | 0;
	    this._fl = this._fl + fl | 0;
	    this._gl = this._gl + gl | 0;
	    this._hl = this._hl + hl | 0;

	    this._a = this._a + a + (this._al >>> 0 < al >>> 0 ? 1 : 0) | 0;
	    this._b = this._b + b + (this._bl >>> 0 < bl >>> 0 ? 1 : 0) | 0;
	    this._c = this._c + c + (this._cl >>> 0 < cl >>> 0 ? 1 : 0) | 0;
	    this._d = this._d + d + (this._dl >>> 0 < dl >>> 0 ? 1 : 0) | 0;
	    this._e = this._e + e + (this._el >>> 0 < el >>> 0 ? 1 : 0) | 0;
	    this._f = this._f + f + (this._fl >>> 0 < fl >>> 0 ? 1 : 0) | 0;
	    this._g = this._g + g + (this._gl >>> 0 < gl >>> 0 ? 1 : 0) | 0;
	    this._h = this._h + h + (this._hl >>> 0 < hl >>> 0 ? 1 : 0) | 0;
	  };

	  Sha512.prototype._hash = function () {
	    var H = new Buffer(64);

	    function writeInt64BE(h, l, offset) {
	      H.writeInt32BE(h, offset);
	      H.writeInt32BE(l, offset + 4);
	    }

	    writeInt64BE(this._a, this._al, 0);
	    writeInt64BE(this._b, this._bl, 8);
	    writeInt64BE(this._c, this._cl, 16);
	    writeInt64BE(this._d, this._dl, 24);
	    writeInt64BE(this._e, this._el, 32);
	    writeInt64BE(this._f, this._fl, 40);
	    writeInt64BE(this._g, this._gl, 48);
	    writeInt64BE(this._h, this._hl, 56);

	    return H;
	  };

	  return Sha512;
	};

/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	/*
	 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
	 * Digest Algorithm, as defined in RFC 1321.
	 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
	 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
	 * Distributed under the BSD License
	 * See http://pajhome.org.uk/crypt/md5 for more info.
	 */

	var helpers = __webpack_require__(37);

	/*
	 * Calculate the MD5 of an array of little-endian words, and a bit length
	 */
	function core_md5(x, len) {
	  /* append padding */
	  x[len >> 5] |= 0x80 << len % 32;
	  x[(len + 64 >>> 9 << 4) + 14] = len;

	  var a = 1732584193;
	  var b = -271733879;
	  var c = -1732584194;
	  var d = 271733878;

	  for (var i = 0; i < x.length; i += 16) {
	    var olda = a;
	    var oldb = b;
	    var oldc = c;
	    var oldd = d;

	    a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936);
	    d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586);
	    c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819);
	    b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330);
	    a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897);
	    d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426);
	    c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341);
	    b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983);
	    a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416);
	    d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417);
	    c = md5_ff(c, d, a, b, x[i + 10], 17, -42063);
	    b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162);
	    a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682);
	    d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101);
	    c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290);
	    b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329);

	    a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510);
	    d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632);
	    c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713);
	    b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302);
	    a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691);
	    d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083);
	    c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335);
	    b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848);
	    a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438);
	    d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690);
	    c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961);
	    b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501);
	    a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467);
	    d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784);
	    c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473);
	    b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734);

	    a = md5_hh(a, b, c, d, x[i + 5], 4, -378558);
	    d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463);
	    c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562);
	    b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556);
	    a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060);
	    d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353);
	    c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632);
	    b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640);
	    a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174);
	    d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222);
	    c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979);
	    b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189);
	    a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487);
	    d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835);
	    c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520);
	    b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651);

	    a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844);
	    d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415);
	    c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905);
	    b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055);
	    a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571);
	    d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606);
	    c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523);
	    b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799);
	    a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359);
	    d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744);
	    c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380);
	    b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649);
	    a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070);
	    d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379);
	    c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259);
	    b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551);

	    a = safe_add(a, olda);
	    b = safe_add(b, oldb);
	    c = safe_add(c, oldc);
	    d = safe_add(d, oldd);
	  }
	  return Array(a, b, c, d);
	}

	/*
	 * These functions implement the four basic operations the algorithm uses.
	 */
	function md5_cmn(q, a, b, x, s, t) {
	  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b);
	}
	function md5_ff(a, b, c, d, x, s, t) {
	  return md5_cmn(b & c | ~b & d, a, b, x, s, t);
	}
	function md5_gg(a, b, c, d, x, s, t) {
	  return md5_cmn(b & d | c & ~d, a, b, x, s, t);
	}
	function md5_hh(a, b, c, d, x, s, t) {
	  return md5_cmn(b ^ c ^ d, a, b, x, s, t);
	}
	function md5_ii(a, b, c, d, x, s, t) {
	  return md5_cmn(c ^ (b | ~d), a, b, x, s, t);
	}

	/*
	 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
	 * to work around bugs in some JS interpreters.
	 */
	function safe_add(x, y) {
	  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
	  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
	  return msw << 16 | lsw & 0xFFFF;
	}

	/*
	 * Bitwise rotate a 32-bit number to the left.
	 */
	function bit_rol(num, cnt) {
	  return num << cnt | num >>> 32 - cnt;
	}

	module.exports = function md5(buf) {
	  return helpers.hash(buf, core_md5, 16);
	};

/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {"use strict";

	var intSize = 4;
	var zeroBuffer = new Buffer(intSize);zeroBuffer.fill(0);
	var chrsz = 8;

	function toArray(buf, bigEndian) {
	  if (buf.length % intSize !== 0) {
	    var len = buf.length + (intSize - buf.length % intSize);
	    buf = Buffer.concat([buf, zeroBuffer], len);
	  }

	  var arr = [];
	  var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
	  for (var i = 0; i < buf.length; i += intSize) {
	    arr.push(fn.call(buf, i));
	  }
	  return arr;
	}

	function toBuffer(arr, size, bigEndian) {
	  var buf = new Buffer(size);
	  var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
	  for (var i = 0; i < arr.length; i++) {
	    fn.call(buf, arr[i], i * 4, true);
	  }
	  return buf;
	}

	function hash(buf, fn, hashSize, bigEndian) {
	  if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
	  var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
	  return toBuffer(arr, hashSize, bigEndian);
	}

	module.exports = { hash: hash };
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';

	module.exports = ripemd160;

	/*
	CryptoJS v3.1.2
	code.google.com/p/crypto-js
	(c) 2009-2013 by Jeff Mott. All rights reserved.
	code.google.com/p/crypto-js/wiki/License
	*/
	/** @preserve
	(c) 2012 by Cédric Mesnil. All rights reserved.

	Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

	    - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
	    - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	// Constants table
	var zl = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];
	var zr = [5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];
	var sl = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6];
	var sr = [8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11];

	var hl = [0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E];
	var hr = [0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000];

	var bytesToWords = function bytesToWords(bytes) {
	  var words = [];
	  for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
	    words[b >>> 5] |= bytes[i] << 24 - b % 32;
	  }
	  return words;
	};

	var wordsToBytes = function wordsToBytes(words) {
	  var bytes = [];
	  for (var b = 0; b < words.length * 32; b += 8) {
	    bytes.push(words[b >>> 5] >>> 24 - b % 32 & 0xFF);
	  }
	  return bytes;
	};

	var processBlock = function processBlock(H, M, offset) {

	  // Swap endian
	  for (var i = 0; i < 16; i++) {
	    var offset_i = offset + i;
	    var M_offset_i = M[offset_i];

	    // Swap
	    M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 0x00ff00ff | (M_offset_i << 24 | M_offset_i >>> 8) & 0xff00ff00;
	  }

	  // Working variables
	  var al, bl, cl, dl, el;
	  var ar, br, cr, dr, er;

	  ar = al = H[0];
	  br = bl = H[1];
	  cr = cl = H[2];
	  dr = dl = H[3];
	  er = el = H[4];
	  // Computation
	  var t;
	  for (var i = 0; i < 80; i += 1) {
	    t = al + M[offset + zl[i]] | 0;
	    if (i < 16) {
	      t += f1(bl, cl, dl) + hl[0];
	    } else if (i < 32) {
	      t += f2(bl, cl, dl) + hl[1];
	    } else if (i < 48) {
	      t += f3(bl, cl, dl) + hl[2];
	    } else if (i < 64) {
	      t += f4(bl, cl, dl) + hl[3];
	    } else {
	      // if (i<80) {
	      t += f5(bl, cl, dl) + hl[4];
	    }
	    t = t | 0;
	    t = rotl(t, sl[i]);
	    t = t + el | 0;
	    al = el;
	    el = dl;
	    dl = rotl(cl, 10);
	    cl = bl;
	    bl = t;

	    t = ar + M[offset + zr[i]] | 0;
	    if (i < 16) {
	      t += f5(br, cr, dr) + hr[0];
	    } else if (i < 32) {
	      t += f4(br, cr, dr) + hr[1];
	    } else if (i < 48) {
	      t += f3(br, cr, dr) + hr[2];
	    } else if (i < 64) {
	      t += f2(br, cr, dr) + hr[3];
	    } else {
	      // if (i<80) {
	      t += f1(br, cr, dr) + hr[4];
	    }
	    t = t | 0;
	    t = rotl(t, sr[i]);
	    t = t + er | 0;
	    ar = er;
	    er = dr;
	    dr = rotl(cr, 10);
	    cr = br;
	    br = t;
	  }
	  // Intermediate hash value
	  t = H[1] + cl + dr | 0;
	  H[1] = H[2] + dl + er | 0;
	  H[2] = H[3] + el + ar | 0;
	  H[3] = H[4] + al + br | 0;
	  H[4] = H[0] + bl + cr | 0;
	  H[0] = t;
	};

	function f1(x, y, z) {
	  return x ^ y ^ z;
	}

	function f2(x, y, z) {
	  return x & y | ~x & z;
	}

	function f3(x, y, z) {
	  return (x | ~y) ^ z;
	}

	function f4(x, y, z) {
	  return x & z | y & ~z;
	}

	function f5(x, y, z) {
	  return x ^ (y | ~z);
	}

	function rotl(x, n) {
	  return x << n | x >>> 32 - n;
	}

	function ripemd160(message) {
	  var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];

	  if (typeof message == 'string') message = new Buffer(message, 'utf8');

	  var m = bytesToWords(message);

	  var nBitsLeft = message.length * 8;
	  var nBitsTotal = message.length * 8;

	  // Add padding
	  m[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;
	  m[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotal << 8 | nBitsTotal >>> 24) & 0x00ff00ff | (nBitsTotal << 24 | nBitsTotal >>> 8) & 0xff00ff00;

	  for (var i = 0; i < m.length; i += 16) {
	    processBlock(H, m, i);
	  }

	  // Swap endian
	  for (var i = 0; i < 5; i++) {
	    // Shortcut
	    var H_i = H[i];

	    // Swap
	    H[i] = (H_i << 8 | H_i >>> 24) & 0x00ff00ff | (H_i << 24 | H_i >>> 8) & 0xff00ff00;
	  }

	  var digestbytes = wordsToBytes(H);
	  return new Buffer(digestbytes);
	}
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';

	var createHash = __webpack_require__(27);

	var zeroBuffer = new Buffer(128);
	zeroBuffer.fill(0);

	module.exports = Hmac;

	function Hmac(alg, key) {
	  if (!(this instanceof Hmac)) return new Hmac(alg, key);
	  this._opad = opad;
	  this._alg = alg;

	  var blocksize = alg === 'sha512' ? 128 : 64;

	  key = this._key = !Buffer.isBuffer(key) ? new Buffer(key) : key;

	  if (key.length > blocksize) {
	    key = createHash(alg).update(key).digest();
	  } else if (key.length < blocksize) {
	    key = Buffer.concat([key, zeroBuffer], blocksize);
	  }

	  var ipad = this._ipad = new Buffer(blocksize);
	  var opad = this._opad = new Buffer(blocksize);

	  for (var i = 0; i < blocksize; i++) {
	    ipad[i] = key[i] ^ 0x36;
	    opad[i] = key[i] ^ 0x5C;
	  }

	  this._hash = createHash(alg).update(ipad);
	}

	Hmac.prototype.update = function (data, enc) {
	  this._hash.update(data, enc);
	  return this;
	};

	Hmac.prototype.digest = function (enc) {
	  var h = this._hash.digest();
	  return createHash(this._alg).update(this._opad).update(h).digest(enc);
	};
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var pbkdf2Export = __webpack_require__(41);

	module.exports = function (crypto, exports) {
	  exports = exports || {};

	  var exported = pbkdf2Export(crypto);

	  exports.pbkdf2 = exported.pbkdf2;
	  exports.pbkdf2Sync = exported.pbkdf2Sync;

	  return exports;
	};

/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(Buffer) {'use strict';

	module.exports = function (crypto) {
	  function pbkdf2(password, salt, iterations, keylen, digest, callback) {
	    if ('function' === typeof digest) {
	      callback = digest;
	      digest = undefined;
	    }

	    if ('function' !== typeof callback) throw new Error('No callback provided to pbkdf2');

	    setTimeout(function () {
	      var result;

	      try {
	        result = pbkdf2Sync(password, salt, iterations, keylen, digest);
	      } catch (e) {
	        return callback(e);
	      }

	      callback(undefined, result);
	    });
	  }

	  function pbkdf2Sync(password, salt, iterations, keylen, digest) {
	    if ('number' !== typeof iterations) throw new TypeError('Iterations not a number');

	    if (iterations < 0) throw new TypeError('Bad iterations');

	    if ('number' !== typeof keylen) throw new TypeError('Key length not a number');

	    if (keylen < 0) throw new TypeError('Bad key length');

	    digest = digest || 'sha1';

	    if (!Buffer.isBuffer(password)) password = new Buffer(password);
	    if (!Buffer.isBuffer(salt)) salt = new Buffer(salt);

	    var hLen,
	        l = 1,
	        r,
	        T;
	    var DK = new Buffer(keylen);
	    var block1 = new Buffer(salt.length + 4);
	    salt.copy(block1, 0, 0, salt.length);

	    for (var i = 1; i <= l; i++) {
	      block1.writeUInt32BE(i, salt.length);

	      var U = crypto.createHmac(digest, password).update(block1).digest();

	      if (!hLen) {
	        hLen = U.length;
	        T = new Buffer(hLen);
	        l = Math.ceil(keylen / hLen);
	        r = keylen - (l - 1) * hLen;

	        if (keylen > (Math.pow(2, 32) - 1) * hLen) throw new TypeError('keylen exceeds maximum length');
	      }

	      U.copy(T, 0, 0, hLen);

	      for (var j = 1; j < iterations; j++) {
	        U = crypto.createHmac(digest, password).update(U).digest();

	        for (var k = 0; k < hLen; k++) {
	          T[k] ^= U[k];
	        }
	      }

	      var destPos = (i - 1) * hLen;
	      var len = i == l ? r : hLen;
	      T.copy(DK, destPos, 0, len);
	    }

	    return DK;
	  }

	  return {
	    pbkdf2: pbkdf2,
	    pbkdf2Sync: pbkdf2Sync
	  };
	};
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(21).Buffer))

/***/ }
/******/ ]);