text: require=(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
  module.exports=[
    {
      "constant": true,
      "inputs": [
        {
          "name": "_owner",
          "type": "address"
        }
      ],
      "name": "name",
      "outputs": [
        {
          "name": "o_name",
          "type": "bytes32"
        }
      ],
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "owner",
      "outputs": [
        {
          "name": "",
          "type": "address"
        }
      ],
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "content",
      "outputs": [
        {
          "name": "",
          "type": "bytes32"
        }
      ],
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "addr",
      "outputs": [
        {
          "name": "",
          "type": "address"
        }
      ],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "reserve",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "subRegistrar",
      "outputs": [
        {
          "name": "",
          "type": "address"
        }
      ],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_newOwner",
          "type": "address"
        }
      ],
      "name": "transfer",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_registrar",
          "type": "address"
        }
      ],
      "name": "setSubRegistrar",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [],
      "name": "Registrar",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_a",
          "type": "address"
        },
        {
          "name": "_primary",
          "type": "bool"
        }
      ],
      "name": "setAddress",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_content",
          "type": "bytes32"
        }
      ],
      "name": "setContent",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "disown",
      "outputs": [],
      "type": "function"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "_name",
          "type": "bytes32"
        },
        {
          "indexed": false,
          "name": "_winner",
          "type": "address"
        }
      ],
      "name": "AuctionEnded",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "_name",
          "type": "bytes32"
        },
        {
          "indexed": false,
          "name": "_bidder",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "_value",
          "type": "uint256"
        }
      ],
      "name": "NewBid",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "name",
          "type": "bytes32"
        }
      ],
      "name": "Changed",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "name",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "name": "addr",
          "type": "address"
        }
      ],
      "name": "PrimaryChanged",
      "type": "event"
    }
  ]
  
  },{}],2:[function(require,module,exports){
  module.exports=[
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "owner",
      "outputs": [
        {
          "name": "",
          "type": "address"
        }
      ],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_refund",
          "type": "address"
        }
      ],
      "name": "disown",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": true,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "addr",
      "outputs": [
        {
          "name": "",
          "type": "address"
        }
      ],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        }
      ],
      "name": "reserve",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_newOwner",
          "type": "address"
        }
      ],
      "name": "transfer",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "_name",
          "type": "bytes32"
        },
        {
          "name": "_a",
          "type": "address"
        }
      ],
      "name": "setAddr",
      "outputs": [],
      "type": "function"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "name",
          "type": "bytes32"
        }
      ],
      "name": "Changed",
      "type": "event"
    }
  ]
  
  },{}],3:[function(require,module,exports){
  module.exports=[
    {
      "constant": false,
      "inputs": [
        {
          "name": "from",
          "type": "bytes32"
        },
        {
          "name": "to",
          "type": "address"
        },
        {
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "transfer",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "from",
          "type": "bytes32"
        },
        {
          "name": "to",
          "type": "address"
        },
        {
          "name": "indirectId",
          "type": "bytes32"
        },
        {
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "icapTransfer",
      "outputs": [],
      "type": "function"
    },
    {
      "constant": false,
      "inputs": [
        {
          "name": "to",
          "type": "bytes32"
        }
      ],
      "name": "deposit",
      "outputs": [],
      "payable": true,
      "type": "function"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "from",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "AnonymousDeposit",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "from",
          "type": "address"
        },
        {
          "indexed": true,
          "name": "to",
          "type": "bytes32"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "Deposit",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "from",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "name": "to",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "Transfer",
      "type": "event"
    },
    {
      "anonymous": false,
      "inputs": [
        {
          "indexed": true,
          "name": "from",
          "type": "bytes32"
        },
        {
          "indexed": true,
          "name": "to",
          "type": "address"
        },
        {
          "indexed": false,
          "name": "indirectId",
          "type": "bytes32"
        },
        {
          "indexed": false,
          "name": "value",
          "type": "uint256"
        }
      ],
      "name": "IcapTransfer",
      "type": "event"
    }
  ]
  
  },{}],4:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeAddress is a prootype that represents address type
   * It matches:
   * address
   * address[]
   * address[4]
   * address[][]
   * address[3][]
   * address[][6][], ...
   */
  var SolidityTypeAddress = function () {
      this._inputFormatter = f.formatInputInt;
      this._outputFormatter = f.formatOutputAddress;
  };
  
  SolidityTypeAddress.prototype = new SolidityType({});
  SolidityTypeAddress.prototype.constructor = SolidityTypeAddress;
  
  SolidityTypeAddress.prototype.isType = function (name) {
      return !!name.match(/address(\[([0-9]*)\])?/);
  };
  
  module.exports = SolidityTypeAddress;
  
  },{"./formatters":9,"./type":14}],5:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeBool is a prootype that represents bool type
   * It matches:
   * bool
   * bool[]
   * bool[4]
   * bool[][]
   * bool[3][]
   * bool[][6][], ...
   */
  var SolidityTypeBool = function () {
      this._inputFormatter = f.formatInputBool;
      this._outputFormatter = f.formatOutputBool;
  };
  
  SolidityTypeBool.prototype = new SolidityType({});
  SolidityTypeBool.prototype.constructor = SolidityTypeBool;
  
  SolidityTypeBool.prototype.isType = function (name) {
      return !!name.match(/^bool(\[([0-9]*)\])*$/);
  };
  
  module.exports = SolidityTypeBool;
  
  },{"./formatters":9,"./type":14}],6:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeBytes is a prototype that represents the bytes type.
   * It matches:
   * bytes
   * bytes[]
   * bytes[4]
   * bytes[][]
   * bytes[3][]
   * bytes[][6][], ...
   * bytes32
   * bytes8[4]
   * bytes[3][]
   */
  var SolidityTypeBytes = function () {
      this._inputFormatter = f.formatInputBytes;
      this._outputFormatter = f.formatOutputBytes;
  };
  
  SolidityTypeBytes.prototype = new SolidityType({});
  SolidityTypeBytes.prototype.constructor = SolidityTypeBytes;
  
  SolidityTypeBytes.prototype.isType = function (name) {
      return !!name.match(/^bytes([0-9]{1,})(\[([0-9]*)\])*$/);
  };
  
  module.exports = SolidityTypeBytes;
  
  },{"./formatters":9,"./type":14}],7:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file coder.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var f = require('./formatters');
  
  var SolidityTypeAddress = require('./address');
  var SolidityTypeBool = require('./bool');
  var SolidityTypeInt = require('./int');
  var SolidityTypeUInt = require('./uint');
  var SolidityTypeDynamicBytes = require('./dynamicbytes');
  var SolidityTypeString = require('./string');
  var SolidityTypeReal = require('./real');
  var SolidityTypeUReal = require('./ureal');
  var SolidityTypeBytes = require('./bytes');
  
  var isDynamic = function (solidityType, type) {
     return solidityType.isDynamicType(type) ||
            solidityType.isDynamicArray(type);
  };
  
  /**
   * SolidityCoder prototype should be used to encode/decode solidity params of any type
   */
  var SolidityCoder = function (types) {
      this._types = types;
  };
  
  /**
   * This method should be used to transform type to SolidityType
   *
   * @method _requireType
   * @param {String} type
   * @returns {SolidityType}
   * @throws {Error} throws if no matching type is found
   */
  SolidityCoder.prototype._requireType = function (type) {
      var solidityType = this._types.filter(function (t) {
          return t.isType(type);
      })[0];
  
      if (!solidityType) {
          throw Error('invalid solidity type!: ' + type);
      }
  
      return solidityType;
  };
  
  /**
   * Should be used to encode plain param
   *
   * @method encodeParam
   * @param {String} type
   * @param {Object} plain param
   * @return {String} encoded plain param
   */
  SolidityCoder.prototype.encodeParam = function (type, param) {
      return this.encodeParams([type], [param]);
  };
  
  /**
   * Should be used to encode list of params
   *
   * @method encodeParams
   * @param {Array} types
   * @param {Array} params
   * @return {String} encoded list of params
   */
  SolidityCoder.prototype.encodeParams = function (types, params) {
      var solidityTypes = this.getSolidityTypes(types);
  
      var encodeds = solidityTypes.map(function (solidityType, index) {
          return solidityType.encode(params[index], types[index]);
      });
  
      var dynamicOffset = solidityTypes.reduce(function (acc, solidityType, index) {
          var staticPartLength = solidityType.staticPartLength(types[index]);
          var roundedStaticPartLength = Math.floor((staticPartLength + 31) / 32) * 32;
  
          return acc + (isDynamic(solidityTypes[index], types[index]) ?
              32 :
              roundedStaticPartLength);
      }, 0);
  
      var result = this.encodeMultiWithOffset(types, solidityTypes, encodeds, dynamicOffset);
  
      return result;
  };
  
  SolidityCoder.prototype.encodeMultiWithOffset = function (types, solidityTypes, encodeds, dynamicOffset) {
      var result = "";
      var self = this;
  
      types.forEach(function (type, i) {
          if (isDynamic(solidityTypes[i], types[i])) {
              result += f.formatInputInt(dynamicOffset).encode();
              var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
              dynamicOffset += e.length / 2;
          } else {
              // don't add length to dynamicOffset. it's already counted
              result += self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
          }
  
          // TODO: figure out nested arrays
      });
  
      types.forEach(function (type, i) {
          if (isDynamic(solidityTypes[i], types[i])) {
              var e = self.encodeWithOffset(types[i], solidityTypes[i], encodeds[i], dynamicOffset);
              dynamicOffset += e.length / 2;
              result += e;
          }
      });
      return result;
  };
  
  SolidityCoder.prototype.encodeWithOffset = function (type, solidityType, encoded, offset) {
      /* jshint maxcomplexity: 17 */
      /* jshint maxdepth: 5 */
  
      var self = this;
      var encodingMode={dynamic:1,static:2,other:3};
  
      var mode=(solidityType.isDynamicArray(type)?encodingMode.dynamic:(solidityType.isStaticArray(type)?encodingMode.static:encodingMode.other));
  
      if(mode !== encodingMode.other){
          var nestedName = solidityType.nestedName(type);
          var nestedStaticPartLength = solidityType.staticPartLength(nestedName);
          var result = (mode === encodingMode.dynamic ? encoded[0] : '');
  
          if (solidityType.isDynamicArray(nestedName)) {
              var previousLength = (mode === encodingMode.dynamic ? 2 : 0);
  
              for (var i = 0; i < encoded.length; i++) {
                  // calculate length of previous item
                  if(mode === encodingMode.dynamic){
                      previousLength += +(encoded[i - 1])[0] || 0;
                  }
                  else if(mode === encodingMode.static){
                      previousLength += +(encoded[i - 1] || [])[0] || 0;
                  }
                  result += f.formatInputInt(offset + i * nestedStaticPartLength + previousLength * 32).encode();
              }
          }
  
          var len= (mode === encodingMode.dynamic ? encoded.length-1 : encoded.length);
          for (var c = 0; c < len; c++) {
              var additionalOffset = result / 2;
              if(mode === encodingMode.dynamic){
                  result += self.encodeWithOffset(nestedName, solidityType, encoded[c + 1], offset +  additionalOffset);
              }
              else if(mode === encodingMode.static){
                  result += self.encodeWithOffset(nestedName, solidityType, encoded[c], offset + additionalOffset);
              }
          }
  
          return result;
      }
  
      return encoded;
  };
  
  
  /**
   * Should be used to decode bytes to plain param
   *
   * @method decodeParam
   * @param {String} type
   * @param {String} bytes
   * @return {Object} plain param
   */
  SolidityCoder.prototype.decodeParam = function (type, bytes) {
      return this.decodeParams([type], bytes)[0];
  };
  
  /**
   * Should be used to decode list of params
   *
   * @method decodeParam
   * @param {Array} types
   * @param {String} bytes
   * @return {Array} array of plain params
   */
  SolidityCoder.prototype.decodeParams = function (types, bytes) {
      var solidityTypes = this.getSolidityTypes(types);
      var offsets = this.getOffsets(types, solidityTypes);
  
      return solidityTypes.map(function (solidityType, index) {
          return solidityType.decode(bytes, offsets[index],  types[index], index);
      });
  };
  
  SolidityCoder.prototype.getOffsets = function (types, solidityTypes) {
      var lengths =  solidityTypes.map(function (solidityType, index) {
          return solidityType.staticPartLength(types[index]);
      });
  
      for (var i = 1; i < lengths.length; i++) {
           // sum with length of previous element
          lengths[i] += lengths[i - 1];
      }
  
      return lengths.map(function (length, index) {
          // remove the current length, so the length is sum of previous elements
          var staticPartLength = solidityTypes[index].staticPartLength(types[index]);
          return length - staticPartLength;
      });
  };
  
  SolidityCoder.prototype.getSolidityTypes = function (types) {
      var self = this;
      return types.map(function (type) {
          return self._requireType(type);
      });
  };
  
  var coder = new SolidityCoder([
      new SolidityTypeAddress(),
      new SolidityTypeBool(),
      new SolidityTypeInt(),
      new SolidityTypeUInt(),
      new SolidityTypeDynamicBytes(),
      new SolidityTypeBytes(),
      new SolidityTypeString(),
      new SolidityTypeReal(),
      new SolidityTypeUReal()
  ]);
  
  module.exports = coder;
  
  },{"./address":4,"./bool":5,"./bytes":6,"./dynamicbytes":8,"./formatters":9,"./int":10,"./real":12,"./string":13,"./uint":15,"./ureal":16}],8:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  var SolidityTypeDynamicBytes = function () {
      this._inputFormatter = f.formatInputDynamicBytes;
      this._outputFormatter = f.formatOutputDynamicBytes;
  };
  
  SolidityTypeDynamicBytes.prototype = new SolidityType({});
  SolidityTypeDynamicBytes.prototype.constructor = SolidityTypeDynamicBytes;
  
  SolidityTypeDynamicBytes.prototype.isType = function (name) {
      return !!name.match(/^bytes(\[([0-9]*)\])*$/);
  };
  
  SolidityTypeDynamicBytes.prototype.isDynamicType = function () {
      return true;
  };
  
  module.exports = SolidityTypeDynamicBytes;
  
  },{"./formatters":9,"./type":14}],9:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file formatters.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var BigNumber = require('bignumber.js');
  var utils = require('../utils/utils');
  var c = require('../utils/config');
  var SolidityParam = require('./param');
  
  
  /**
   * Formats input value to byte representation of int
   * If value is negative, return it's two's complement
   * If the value is floating point, round it down
   *
   * @method formatInputInt
   * @param {String|Number|BigNumber} value that needs to be formatted
   * @returns {SolidityParam}
   */
  var formatInputInt = function (value) {
      BigNumber.config(c.ETH_BIGNUMBER_ROUNDING_MODE);
      var result = utils.padLeft(utils.toTwosComplement(value).toString(16), 64);
      return new SolidityParam(result);
  };
  
  /**
   * Formats input bytes
   *
   * @method formatInputBytes
   * @param {String}
   * @returns {SolidityParam}
   */
  var formatInputBytes = function (value) {
      var result = utils.toHex(value).substr(2);
      var l = Math.floor((result.length + 63) / 64);
      result = utils.padRight(result, l * 64);
      return new SolidityParam(result);
  };
  
  /**
   * Formats input bytes
   *
   * @method formatDynamicInputBytes
   * @param {String}
   * @returns {SolidityParam}
   */
  var formatInputDynamicBytes = function (value) {
      var result = utils.toHex(value).substr(2);
      if (result.length % 2 !== 0) {
          result = "0" + result;
      }
      var length = result.length / 2;
      var l = Math.floor((result.length + 63) / 64);
      result = utils.padRight(result, l * 64);
      return new SolidityParam(formatInputInt(length).value + result);
  };
  
  /**
   * Formats input value to byte representation of string
   *
   * @method formatInputString
   * @param {String}
   * @returns {SolidityParam}
   */
  var formatInputString = function (value) {
      var result = utils.fromUtf8(value).substr(2);
      var length = result.length / 2;
      var l = Math.floor((result.length + 63) / 64);
      result = utils.padRight(result, l * 64);
      return new SolidityParam(formatInputInt(length).value + result);
  };
  
  /**
   * Formats input value to byte representation of bool
   *
   * @method formatInputBool
   * @param {Boolean}
   * @returns {SolidityParam}
   */
  var formatInputBool = function (value) {
      var result = '000000000000000000000000000000000000000000000000000000000000000' + (value ?  '1' : '0');
      return new SolidityParam(result);
  };
  
  /**
   * Formats input value to byte representation of real
   * Values are multiplied by 2^m and encoded as integers
   *
   * @method formatInputReal
   * @param {String|Number|BigNumber}
   * @returns {SolidityParam}
   */
  var formatInputReal = function (value) {
      return formatInputInt(new BigNumber(value).times(new BigNumber(2).pow(128)));
  };
  
  /**
   * Check if input value is negative
   *
   * @method signedIsNegative
   * @param {String} value is hex format
   * @returns {Boolean} true if it is negative, otherwise false
   */
  var signedIsNegative = function (value) {
      return (new BigNumber(value.substr(0, 1), 16).toString(2).substr(0, 1)) === '1';
  };
  
  /**
   * Formats right-aligned output bytes to int
   *
   * @method formatOutputInt
   * @param {SolidityParam} param
   * @returns {BigNumber} right-aligned output bytes formatted to big number
   */
  var formatOutputInt = function (param) {
      var value = param.staticPart() || "0";
  
      // check if it's negative number
      // it it is, return two's complement
      if (signedIsNegative(value)) {
          return new BigNumber(value, 16).minus(new BigNumber('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16)).minus(1);
      }
      return new BigNumber(value, 16);
  };
  
  /**
   * Formats right-aligned output bytes to uint
   *
   * @method formatOutputUInt
   * @param {SolidityParam}
   * @returns {BigNumeber} right-aligned output bytes formatted to uint
   */
  var formatOutputUInt = function (param) {
      var value = param.staticPart() || "0";
      return new BigNumber(value, 16);
  };
  
  /**
   * Formats right-aligned output bytes to real
   *
   * @method formatOutputReal
   * @param {SolidityParam}
   * @returns {BigNumber} input bytes formatted to real
   */
  var formatOutputReal = function (param) {
      return formatOutputInt(param).dividedBy(new BigNumber(2).pow(128));
  };
  
  /**
   * Formats right-aligned output bytes to ureal
   *
   * @method formatOutputUReal
   * @param {SolidityParam}
   * @returns {BigNumber} input bytes formatted to ureal
   */
  var formatOutputUReal = function (param) {
      return formatOutputUInt(param).dividedBy(new BigNumber(2).pow(128));
  };
  
  /**
   * Should be used to format output bool
   *
   * @method formatOutputBool
   * @param {SolidityParam}
   * @returns {Boolean} right-aligned input bytes formatted to bool
   */
  var formatOutputBool = function (param) {
      return param.staticPart() === '0000000000000000000000000000000000000000000000000000000000000001' ? true : false;
  };
  
  /**
   * Should be used to format output bytes
   *
   * @method formatOutputBytes
   * @param {SolidityParam} left-aligned hex representation of string
   * @param {String} name type name
   * @returns {String} hex string
   */
  var formatOutputBytes = function (param, name) {
      var matches = name.match(/^bytes([0-9]*)/);
      var size = parseInt(matches[1]);
      return '0x' + param.staticPart().slice(0, 2 * size);
  };
  
  /**
   * Should be used to format output bytes
   *
   * @method formatOutputDynamicBytes
   * @param {SolidityParam} left-aligned hex representation of string
   * @returns {String} hex string
   */
  var formatOutputDynamicBytes = function (param) {
      var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2;
      return '0x' + param.dynamicPart().substr(64, length);
  };
  
  /**
   * Should be used to format output string
   *
   * @method formatOutputString
   * @param {SolidityParam} left-aligned hex representation of string
   * @returns {String} ascii string
   */
  var formatOutputString = function (param) {
      var length = (new BigNumber(param.dynamicPart().slice(0, 64), 16)).toNumber() * 2;
      return utils.toUtf8(param.dynamicPart().substr(64, length));
  };
  
  /**
   * Should be used to format output address
   *
   * @method formatOutputAddress
   * @param {SolidityParam} right-aligned input bytes
   * @returns {String} address
   */
  var formatOutputAddress = function (param) {
      var value = param.staticPart();
      return "0x" + value.slice(value.length - 40, value.length);
  };
  
  module.exports = {
      formatInputInt: formatInputInt,
      formatInputBytes: formatInputBytes,
      formatInputDynamicBytes: formatInputDynamicBytes,
      formatInputString: formatInputString,
      formatInputBool: formatInputBool,
      formatInputReal: formatInputReal,
      formatOutputInt: formatOutputInt,
      formatOutputUInt: formatOutputUInt,
      formatOutputReal: formatOutputReal,
      formatOutputUReal: formatOutputUReal,
      formatOutputBool: formatOutputBool,
      formatOutputBytes: formatOutputBytes,
      formatOutputDynamicBytes: formatOutputDynamicBytes,
      formatOutputString: formatOutputString,
      formatOutputAddress: formatOutputAddress
  };
  
  },{"../utils/config":18,"../utils/utils":20,"./param":11,"bignumber.js":"bignumber.js"}],10:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeInt is a prootype that represents int type
   * It matches:
   * int
   * int[]
   * int[4]
   * int[][]
   * int[3][]
   * int[][6][], ...
   * int32
   * int64[]
   * int8[4]
   * int256[][]
   * int[3][]
   * int64[][6][], ...
   */
  var SolidityTypeInt = function () {
      this._inputFormatter = f.formatInputInt;
      this._outputFormatter = f.formatOutputInt;
  };
  
  SolidityTypeInt.prototype = new SolidityType({});
  SolidityTypeInt.prototype.constructor = SolidityTypeInt;
  
  SolidityTypeInt.prototype.isType = function (name) {
      return !!name.match(/^int([0-9]*)?(\[([0-9]*)\])*$/);
  };
  
  module.exports = SolidityTypeInt;
  
  },{"./formatters":9,"./type":14}],11:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file param.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var utils = require('../utils/utils');
  
  /**
   * SolidityParam object prototype.
   * Should be used when encoding, decoding solidity bytes
   */
  var SolidityParam = function (value, offset) {
      this.value = value || '';
      this.offset = offset; // offset in bytes
  };
  
  /**
   * This method should be used to get length of params's dynamic part
   * 
   * @method dynamicPartLength
   * @returns {Number} length of dynamic part (in bytes)
   */
  SolidityParam.prototype.dynamicPartLength = function () {
      return this.dynamicPart().length / 2;
  };
  
  /**
   * This method should be used to create copy of solidity param with different offset
   *
   * @method withOffset
   * @param {Number} offset length in bytes
   * @returns {SolidityParam} new solidity param with applied offset
   */
  SolidityParam.prototype.withOffset = function (offset) {
      return new SolidityParam(this.value, offset);
  };
  
  /**
   * This method should be used to combine solidity params together
   * eg. when appending an array
   *
   * @method combine
   * @param {SolidityParam} param with which we should combine
   * @param {SolidityParam} result of combination
   */
  SolidityParam.prototype.combine = function (param) {
      return new SolidityParam(this.value + param.value); 
  };
  
  /**
   * This method should be called to check if param has dynamic size.
   * If it has, it returns true, otherwise false
   *
   * @method isDynamic
   * @returns {Boolean}
   */
  SolidityParam.prototype.isDynamic = function () {
      return this.offset !== undefined;
  };
  
  /**
   * This method should be called to transform offset to bytes
   *
   * @method offsetAsBytes
   * @returns {String} bytes representation of offset
   */
  SolidityParam.prototype.offsetAsBytes = function () {
      return !this.isDynamic() ? '' : utils.padLeft(utils.toTwosComplement(this.offset).toString(16), 64);
  };
  
  /**
   * This method should be called to get static part of param
   *
   * @method staticPart
   * @returns {String} offset if it is a dynamic param, otherwise value
   */
  SolidityParam.prototype.staticPart = function () {
      if (!this.isDynamic()) {
          return this.value; 
      } 
      return this.offsetAsBytes();
  };
  
  /**
   * This method should be called to get dynamic part of param
   *
   * @method dynamicPart
   * @returns {String} returns a value if it is a dynamic param, otherwise empty string
   */
  SolidityParam.prototype.dynamicPart = function () {
      return this.isDynamic() ? this.value : '';
  };
  
  /**
   * This method should be called to encode param
   *
   * @method encode
   * @returns {String}
   */
  SolidityParam.prototype.encode = function () {
      return this.staticPart() + this.dynamicPart();
  };
  
  /**
   * This method should be called to encode array of params
   *
   * @method encodeList
   * @param {Array[SolidityParam]} params
   * @returns {String}
   */
  SolidityParam.encodeList = function (params) {
      
      // updating offsets
      var totalOffset = params.length * 32;
      var offsetParams = params.map(function (param) {
          if (!param.isDynamic()) {
              return param;
          }
          var offset = totalOffset;
          totalOffset += param.dynamicPartLength();
          return param.withOffset(offset);
      });
  
      // encode everything!
      return offsetParams.reduce(function (result, param) {
          return result + param.dynamicPart();
      }, offsetParams.reduce(function (result, param) {
          return result + param.staticPart();
      }, ''));
  };
  
  
  
  module.exports = SolidityParam;
  
  
  },{"../utils/utils":20}],12:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeReal is a prootype that represents real type
   * It matches:
   * real
   * real[]
   * real[4]
   * real[][]
   * real[3][]
   * real[][6][], ...
   * real32
   * real64[]
   * real8[4]
   * real256[][]
   * real[3][]
   * real64[][6][], ...
   */
  var SolidityTypeReal = function () {
      this._inputFormatter = f.formatInputReal;
      this._outputFormatter = f.formatOutputReal;
  };
  
  SolidityTypeReal.prototype = new SolidityType({});
  SolidityTypeReal.prototype.constructor = SolidityTypeReal;
  
  SolidityTypeReal.prototype.isType = function (name) {
      return !!name.match(/real([0-9]*)?(\[([0-9]*)\])?/);
  };
  
  module.exports = SolidityTypeReal;
  
  },{"./formatters":9,"./type":14}],13:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  var SolidityTypeString = function () {
      this._inputFormatter = f.formatInputString;
      this._outputFormatter = f.formatOutputString;
  };
  
  SolidityTypeString.prototype = new SolidityType({});
  SolidityTypeString.prototype.constructor = SolidityTypeString;
  
  SolidityTypeString.prototype.isType = function (name) {
      return !!name.match(/^string(\[([0-9]*)\])*$/);
  };
  
  SolidityTypeString.prototype.isDynamicType = function () {
      return true;
  };
  
  module.exports = SolidityTypeString;
  
  },{"./formatters":9,"./type":14}],14:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityParam = require('./param');
  
  /**
   * SolidityType prototype is used to encode/decode solidity params of certain type
   */
  var SolidityType = function (config) {
      this._inputFormatter = config.inputFormatter;
      this._outputFormatter = config.outputFormatter;
  };
  
  /**
   * Should be used to determine if this SolidityType do match given name
   *
   * @method isType
   * @param {String} name
   * @return {Bool} true if type match this SolidityType, otherwise false
   */
  SolidityType.prototype.isType = function (name) {
      throw "this method should be overrwritten for type " + name;
  };
  
  /**
   * Should be used to determine what is the length of static part in given type
   *
   * @method staticPartLength
   * @param {String} name
   * @return {Number} length of static part in bytes
   */
  SolidityType.prototype.staticPartLength = function (name) {
      // If name isn't an array then treat it like a single element array.
      return (this.nestedTypes(name) || ['[1]'])
          .map(function (type) {
              // the length of the nested array
              return parseInt(type.slice(1, -1), 10) || 1;
          })
          .reduce(function (previous, current) {
              return previous * current;
          // all basic types are 32 bytes long
          }, 32);
  };
  
  /**
   * Should be used to determine if type is dynamic array
   * eg:
   * "type[]" => true
   * "type[4]" => false
   *
   * @method isDynamicArray
   * @param {String} name
   * @return {Bool} true if the type is dynamic array
   */
  SolidityType.prototype.isDynamicArray = function (name) {
      var nestedTypes = this.nestedTypes(name);
      return !!nestedTypes && !nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g);
  };
  
  /**
   * Should be used to determine if type is static array
   * eg:
   * "type[]" => false
   * "type[4]" => true
   *
   * @method isStaticArray
   * @param {String} name
   * @return {Bool} true if the type is static array
   */
  SolidityType.prototype.isStaticArray = function (name) {
      var nestedTypes = this.nestedTypes(name);
      return !!nestedTypes && !!nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g);
  };
  
  /**
   * Should return length of static array
   * eg.
   * "int[32]" => 32
   * "int256[14]" => 14
   * "int[2][3]" => 3
   * "int" => 1
   * "int[1]" => 1
   * "int[]" => 1
   *
   * @method staticArrayLength
   * @param {String} name
   * @return {Number} static array length
   */
  SolidityType.prototype.staticArrayLength = function (name) {
      var nestedTypes = this.nestedTypes(name);
      if (nestedTypes) {
         return parseInt(nestedTypes[nestedTypes.length - 1].match(/[0-9]{1,}/g) || 1);
      }
      return 1;
  };
  
  /**
   * Should return nested type
   * eg.
   * "int[32]" => "int"
   * "int256[14]" => "int256"
   * "int[2][3]" => "int[2]"
   * "int" => "int"
   * "int[]" => "int"
   *
   * @method nestedName
   * @param {String} name
   * @return {String} nested name
   */
  SolidityType.prototype.nestedName = function (name) {
      // remove last [] in name
      var nestedTypes = this.nestedTypes(name);
      if (!nestedTypes) {
          return name;
      }
  
      return name.substr(0, name.length - nestedTypes[nestedTypes.length - 1].length);
  };
  
  /**
   * Should return true if type has dynamic size by default
   * such types are "string", "bytes"
   *
   * @method isDynamicType
   * @param {String} name
   * @return {Bool} true if is dynamic, otherwise false
   */
  SolidityType.prototype.isDynamicType = function () {
      return false;
  };
  
  /**
   * Should return array of nested types
   * eg.
   * "int[2][3][]" => ["[2]", "[3]", "[]"]
   * "int[] => ["[]"]
   * "int" => null
   *
   * @method nestedTypes
   * @param {String} name
   * @return {Array} array of nested types
   */
  SolidityType.prototype.nestedTypes = function (name) {
      // return list of strings eg. "[]", "[3]", "[]", "[2]"
      return name.match(/(\[[0-9]*\])/g);
  };
  
  /**
   * Should be used to encode the value
   *
   * @method encode
   * @param {Object} value
   * @param {String} name
   * @return {String} encoded value
   */
  SolidityType.prototype.encode = function (value, name) {
      var self = this;
      if (this.isDynamicArray(name)) {
  
          return (function () {
              var length = value.length;                          // in int
              var nestedName = self.nestedName(name);
  
              var result = [];
              result.push(f.formatInputInt(length).encode());
  
              value.forEach(function (v) {
                  result.push(self.encode(v, nestedName));
              });
  
              return result;
          })();
  
      } else if (this.isStaticArray(name)) {
  
          return (function () {
              var length = self.staticArrayLength(name);          // in int
              var nestedName = self.nestedName(name);
  
              var result = [];
              for (var i = 0; i < length; i++) {
                  result.push(self.encode(value[i], nestedName));
              }
  
              return result;
          })();
  
      }
  
      return this._inputFormatter(value, name).encode();
  };
  
  /**
   * Should be used to decode value from bytes
   *
   * @method decode
   * @param {String} bytes
   * @param {Number} offset in bytes
   * @param {String} name type name
   * @returns {Object} decoded value
   */
  SolidityType.prototype.decode = function (bytes, offset, name) {
      var self = this;
  
      if (this.isDynamicArray(name)) {
  
          return (function () {
              var arrayOffset = parseInt('0x' + bytes.substr(offset * 2, 64)); // in bytes
              var length = parseInt('0x' + bytes.substr(arrayOffset * 2, 64)); // in int
              var arrayStart = arrayOffset + 32; // array starts after length; // in bytes
  
              var nestedName = self.nestedName(name);
              var nestedStaticPartLength = self.staticPartLength(nestedName);  // in bytes
              var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32;
              var result = [];
  
              for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) {
                  result.push(self.decode(bytes, arrayStart + i, nestedName));
              }
  
              return result;
          })();
  
      } else if (this.isStaticArray(name)) {
  
          return (function () {
              var length = self.staticArrayLength(name);                      // in int
              var arrayStart = offset;                                        // in bytes
  
              var nestedName = self.nestedName(name);
              var nestedStaticPartLength = self.staticPartLength(nestedName); // in bytes
              var roundedNestedStaticPartLength = Math.floor((nestedStaticPartLength + 31) / 32) * 32;
              var result = [];
  
              for (var i = 0; i < length * roundedNestedStaticPartLength; i += roundedNestedStaticPartLength) {
                  result.push(self.decode(bytes, arrayStart + i, nestedName));
              }
  
              return result;
          })();
      } else if (this.isDynamicType(name)) {
  
          return (function () {
              var dynamicOffset = parseInt('0x' + bytes.substr(offset * 2, 64));      // in bytes
              var length = parseInt('0x' + bytes.substr(dynamicOffset * 2, 64));      // in bytes
              var roundedLength = Math.floor((length + 31) / 32);                     // in int
              var param = new SolidityParam(bytes.substr(dynamicOffset * 2, ( 1 + roundedLength) * 64), 0);
              return self._outputFormatter(param, name);
          })();
      }
  
      var length = this.staticPartLength(name);
      var param = new SolidityParam(bytes.substr(offset * 2, length * 2));
      return this._outputFormatter(param, name);
  };
  
  module.exports = SolidityType;
  
  },{"./formatters":9,"./param":11}],15:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeUInt is a prootype that represents uint type
   * It matches:
   * uint
   * uint[]
   * uint[4]
   * uint[][]
   * uint[3][]
   * uint[][6][], ...
   * uint32
   * uint64[]
   * uint8[4]
   * uint256[][]
   * uint[3][]
   * uint64[][6][], ...
   */
  var SolidityTypeUInt = function () {
      this._inputFormatter = f.formatInputInt;
      this._outputFormatter = f.formatOutputUInt;
  };
  
  SolidityTypeUInt.prototype = new SolidityType({});
  SolidityTypeUInt.prototype.constructor = SolidityTypeUInt;
  
  SolidityTypeUInt.prototype.isType = function (name) {
      return !!name.match(/^uint([0-9]*)?(\[([0-9]*)\])*$/);
  };
  
  module.exports = SolidityTypeUInt;
  
  },{"./formatters":9,"./type":14}],16:[function(require,module,exports){
  var f = require('./formatters');
  var SolidityType = require('./type');
  
  /**
   * SolidityTypeUReal is a prootype that represents ureal type
   * It matches:
   * ureal
   * ureal[]
   * ureal[4]
   * ureal[][]
   * ureal[3][]
   * ureal[][6][], ...
   * ureal32
   * ureal64[]
   * ureal8[4]
   * ureal256[][]
   * ureal[3][]
   * ureal64[][6][], ...
   */
  var SolidityTypeUReal = function () {
      this._inputFormatter = f.formatInputReal;
      this._outputFormatter = f.formatOutputUReal;
  };
  
  SolidityTypeUReal.prototype = new SolidityType({});
  SolidityTypeUReal.prototype.constructor = SolidityTypeUReal;
  
  SolidityTypeUReal.prototype.isType = function (name) {
      return !!name.match(/^ureal([0-9]*)?(\[([0-9]*)\])*$/);
  };
  
  module.exports = SolidityTypeUReal;
  
  },{"./formatters":9,"./type":14}],17:[function(require,module,exports){
  'use strict';
  
  // go env doesn't have and need XMLHttpRequest
  if (typeof XMLHttpRequest === 'undefined') {
      exports.XMLHttpRequest = {};
  } else {
      exports.XMLHttpRequest = XMLHttpRequest; // jshint ignore:line
  }
  
  
  },{}],18:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file config.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  /**
   * Utils
   * 
   * @module utils
   */
  
  /**
   * Utility functions
   * 
   * @class [utils] config
   * @constructor
   */
  
  
  /// required to define ETH_BIGNUMBER_ROUNDING_MODE
  var BigNumber = require('bignumber.js');
  
  var ETH_UNITS = [
      'wei',
      'kwei',
      'Mwei',
      'Gwei',
      'szabo',
      'finney',
      'femtoether',
      'picoether',
      'nanoether',
      'microether',
      'milliether',
      'nano',
      'micro',
      'milli',
      'ether',
      'grand',
      'Mether',
      'Gether',
      'Tether',
      'Pether',
      'Eether',
      'Zether',
      'Yether',
      'Nether',
      'Dether',
      'Vether',
      'Uether'
  ];
  
  module.exports = {
      ETH_PADDING: 32,
      ETH_SIGNATURE_LENGTH: 4,
      ETH_UNITS: ETH_UNITS,
      ETH_BIGNUMBER_ROUNDING_MODE: { ROUNDING_MODE: BigNumber.ROUND_DOWN },
      ETH_POLLING_TIMEOUT: 1000/2,
      defaultBlock: 'latest',
      defaultAccount: undefined
  };
  
  
  },{"bignumber.js":"bignumber.js"}],19:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file sha3.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var CryptoJS = require('crypto-js');
  var sha3 = require('crypto-js/sha3');
  
  module.exports = function (value, options) {
      if (options && options.encoding === 'hex') {
          if (value.length > 2 && value.substr(0, 2) === '0x') {
              value = value.substr(2);
          }
          value = CryptoJS.enc.Hex.parse(value);
      }
  
      return sha3(value, {
          outputLength: 256
      }).toString();
  };
  
  
  },{"crypto-js":67,"crypto-js/sha3":88}],20:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file utils.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  /**
   * Utils
   *
   * @module utils
   */
  
  /**
   * Utility functions
   *
   * @class [utils] utils
   * @constructor
   */
  
  
  var BigNumber = require('bignumber.js');
  var sha3 = require('./sha3.js');
  var utf8 = require('utf8');
  
  var unitMap = {
      'noether':      '0',
      'wei':          '1',
      'kwei':         '1000',
      'Kwei':         '1000',
      'babbage':      '1000',
      'femtoether':   '1000',
      'mwei':         '1000000',
      'Mwei':         '1000000',
      'lovelace':     '1000000',
      'picoether':    '1000000',
      'gwei':         '1000000000',
      'Gwei':         '1000000000',
      'shannon':      '1000000000',
      'nanoether':    '1000000000',
      'nano':         '1000000000',
      'szabo':        '1000000000000',
      'microether':   '1000000000000',
      'micro':        '1000000000000',
      'finney':       '1000000000000000',
      'milliether':   '1000000000000000',
      'milli':        '1000000000000000',
      'ether':        '1000000000000000000',
      'kether':       '1000000000000000000000',
      'grand':        '1000000000000000000000',
      'mether':       '1000000000000000000000000',
      'gether':       '1000000000000000000000000000',
      'tether':       '1000000000000000000000000000000'
  };
  
  /**
   * Should be called to pad string to expected length
   *
   * @method padLeft
   * @param {String} string to be padded
   * @param {Number} characters that result string should have
   * @param {String} sign, by default 0
   * @returns {String} right aligned string
   */
  var padLeft = function (string, chars, sign) {
      return new Array(chars - string.length + 1).join(sign ? sign : "0") + string;
  };
  
  /**
   * Should be called to pad string to expected length
   *
   * @method padRight
   * @param {String} string to be padded
   * @param {Number} characters that result string should have
   * @param {String} sign, by default 0
   * @returns {String} right aligned string
   */
  var padRight = function (string, chars, sign) {
      return string + (new Array(chars - string.length + 1).join(sign ? sign : "0"));
  };
  
  /**
   * Should be called to get utf8 from it's hex representation
   *
   * @method toUtf8
   * @param {String} string in hex
   * @returns {String} ascii string representation of hex value
   */
  var toUtf8 = function(hex) {
  // Find termination
      var str = "";
      var i = 0, l = hex.length;
      if (hex.substring(0, 2) === '0x') {
          i = 2;
      }
      for (; i < l; i+=2) {
          var code = parseInt(hex.substr(i, 2), 16);
          if (code === 0)
              break;
          str += String.fromCharCode(code);
      }
  
      return utf8.decode(str);
  };
  
  /**
   * Should be called to get ascii from it's hex representation
   *
   * @method toAscii
   * @param {String} string in hex
   * @returns {String} ascii string representation of hex value
   */
  var toAscii = function(hex) {
  // Find termination
      var str = "";
      var i = 0, l = hex.length;
      if (hex.substring(0, 2) === '0x') {
          i = 2;
      }
      for (; i < l; i+=2) {
          var code = parseInt(hex.substr(i, 2), 16);
          str += String.fromCharCode(code);
      }
  
      return str;
  };
  
  /**
   * Should be called to get hex representation (prefixed by 0x) of utf8 string
   *
   * @method fromUtf8
   * @param {String} string
   * @param {Boolean} allowZero to convert code point zero to 00 instead of end of string
   * @returns {String} hex representation of input string
   */
  var fromUtf8 = function(str, allowZero) {
      str = utf8.encode(str);
      var hex = "";
      for(var i = 0; i < str.length; i++) {
          var code = str.charCodeAt(i);
          if (code === 0) {
              if (allowZero) {
                  hex += '00';
              } else {
                  break;
              }
          } else {
              var n = code.toString(16);
              hex += n.length < 2 ? '0' + n : n;
          }
      }
  
      return "0x" + hex;
  };
  
  /**
   * Should be called to get hex representation (prefixed by 0x) of ascii string
   *
   * @method fromAscii
   * @param {String} string
   * @param {Number} optional padding
   * @returns {String} hex representation of input string
   */
  var fromAscii = function(str, num) {
      var hex = "";
      for(var i = 0; i < str.length; i++) {
          var code = str.charCodeAt(i);
          var n = code.toString(16);
          hex += n.length < 2 ? '0' + n : n;
      }
  
      return "0x" + hex.padEnd(num,'0');
  };
  
  /**
   * Should be used to create full function/event name from json abi
   *
   * @method transformToFullName
   * @param {Object} json-abi
   * @return {String} full fnction/event name
   */
  var transformToFullName = function (json) {
      if (json.name.indexOf('(') !== -1) {
          return json.name;
      }
  
      var typeName = json.inputs.map(function(i){return i.type; }).join();
      return json.name + '(' + typeName + ')';
  };
  
  /**
   * Should be called to get display name of contract function
   *
   * @method extractDisplayName
   * @param {String} name of function/event
   * @returns {String} display name for function/event eg. multiply(uint256) -> multiply
   */
  var extractDisplayName = function (name) {
      var stBracket = name.indexOf('(');
      var endBracket = name.indexOf(')');
      return (stBracket !== -1 && endBracket !== -1) ? name.substr(0, stBracket) : name;
  };
  
  /**
   * Should be called to get type name of contract function
   *
   * @method extractTypeName
   * @param {String} name of function/event
   * @returns {String} type name for function/event eg. multiply(uint256) -> uint256
   */
  var extractTypeName = function (name) {
      var stBracket = name.indexOf('(');
      var endBracket = name.indexOf(')');
      return (stBracket !== -1 && endBracket !== -1) ? name.substr(stBracket + 1, endBracket - stBracket - 1).replace(' ', '') : "";
  };
  
  /**
   * Converts value to it's decimal representation in string
   *
   * @method toDecimal
   * @param {String|Number|BigNumber}
   * @return {String}
   */
  var toDecimal = function (value) {
      return toBigNumber(value).toNumber();
  };
  
  /**
   * Converts value to it's hex representation
   *
   * @method fromDecimal
   * @param {String|Number|BigNumber}
   * @return {String}
   */
  var fromDecimal = function (value) {
      var number = toBigNumber(value);
      var result = number.toString(16);
  
      return number.lessThan(0) ? '-0x' + result.substr(1) : '0x' + result;
  };
  
  /**
   * Auto converts any given value into it's hex representation.
   *
   * And even stringifys objects before.
   *
   * @method toHex
   * @param {String|Number|BigNumber|Object}
   * @return {String}
   */
  var toHex = function (val) {
      /*jshint maxcomplexity: 8 */
  
      if (isBoolean(val))
          return fromDecimal(+val);
  
      if (isBigNumber(val))
          return fromDecimal(val);
  
      if (typeof val === 'object')
          return fromUtf8(JSON.stringify(val));
  
      // if its a negative number, pass it through fromDecimal
      if (isString(val)) {
          if (val.indexOf('-0x') === 0)
              return fromDecimal(val);
          else if(val.indexOf('0x') === 0)
              return val;
          else if (!isFinite(val))
              return fromUtf8(val,1);
      }
  
      return fromDecimal(val);
  };
  
  /**
   * Returns value of unit in Wei
   *
   * @method getValueOfUnit
   * @param {String} unit the unit to convert to, default ether
   * @returns {BigNumber} value of the unit (in Wei)
   * @throws error if the unit is not correct:w
   */
  var getValueOfUnit = function (unit) {
      unit = unit ? unit.toLowerCase() : 'ether';
      var unitValue = unitMap[unit];
      if (unitValue === undefined) {
          throw new Error('This unit doesn\'t exists, please use the one of the following units' + JSON.stringify(unitMap, null, 2));
      }
      return new BigNumber(unitValue, 10);
  };
  
  /**
   * Takes a number of wei and converts it to any other ether unit.
   *
   * Possible units are:
   *   SI Short   SI Full        Effigy       Other
   * - kwei       femtoether     babbage
   * - mwei       picoether      lovelace
   * - gwei       nanoether      shannon      nano
   * - --         microether     szabo        micro
   * - --         milliether     finney       milli
   * - ether      --             --
   * - kether                    --           grand
   * - mether
   * - gether
   * - tether
   *
   * @method fromWei
   * @param {Number|String} number can be a number, number string or a HEX of a decimal
   * @param {String} unit the unit to convert to, default ether
   * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
  */
  var fromWei = function(number, unit) {
      var returnValue = toBigNumber(number).dividedBy(getValueOfUnit(unit));
  
      return isBigNumber(number) ? returnValue : returnValue.toString(10);
  };
  
  /**
   * Takes a number of a unit and converts it to wei.
   *
   * Possible units are:
   *   SI Short   SI Full        Effigy       Other
   * - kwei       femtoether     babbage
   * - mwei       picoether      lovelace
   * - gwei       nanoether      shannon      nano
   * - --         microether     szabo        micro
   * - --         milliether     finney       milli
   * - ether      --             --
   * - kether                    --           grand
   * - mether
   * - gether
   * - tether
   *
   * @method toWei
   * @param {Number|String|BigNumber} number can be a number, number string or a HEX of a decimal
   * @param {String} unit the unit to convert from, default ether
   * @return {String|Object} When given a BigNumber object it returns one as well, otherwise a number
  */
  var toWei = function(number, unit) {
      var returnValue = toBigNumber(number).times(getValueOfUnit(unit));
  
      return isBigNumber(number) ? returnValue : returnValue.toString(10);
  };
  
  /**
   * Takes an input and transforms it into an bignumber
   *
   * @method toBigNumber
   * @param {Number|String|BigNumber} a number, string, HEX string or BigNumber
   * @return {BigNumber} BigNumber
  */
  var toBigNumber = function(number) {
      /*jshint maxcomplexity:5 */
      number = number || 0;
      if (isBigNumber(number))
          return number;
  
      if (isString(number) && (number.indexOf('0x') === 0 || number.indexOf('-0x') === 0)) {
          return new BigNumber(number.replace('0x',''), 16);
      }
  
      return new BigNumber(number.toString(10), 10);
  };
  
  /**
   * Takes and input transforms it into bignumber and if it is negative value, into two's complement
   *
   * @method toTwosComplement
   * @param {Number|String|BigNumber}
   * @return {BigNumber}
   */
  var toTwosComplement = function (number) {
      var bigNumber = toBigNumber(number).round();
      if (bigNumber.lessThan(0)) {
          return new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).plus(bigNumber).plus(1);
      }
      return bigNumber;
  };
  
  /**
   * Checks if the given string is strictly an address
   *
   * @method isStrictAddress
   * @param {String} address the given HEX adress
   * @return {Boolean}
  */
  var isStrictAddress = function (address) {
      return /^0x[0-9a-f]{40}$/i.test(address);
  };
  
  /**
   * Checks if the given string is an address
   *
   * @method isAddress
   * @param {String} address the given HEX adress
   * @return {Boolean}
  */
  var isAddress = function (address) {
      if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
          // check if it has the basic requirements of an address
          return false;
      } else if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
          // If it's all small caps or all all caps, return true
          return true;
      } else {
          // Otherwise check each case
          return isChecksumAddress(address);
      }
  };
  
  /**
   * Checks if the given string is a checksummed address
   *
   * @method isChecksumAddress
   * @param {String} address the given HEX adress
   * @return {Boolean}
  */
  var isChecksumAddress = function (address) {
      // Check each case
      address = address.replace('0x','');
      var addressHash = sha3(address.toLowerCase());
  
      for (var i = 0; i < 40; i++ ) {
          // the nth letter should be uppercase if the nth digit of casemap is 1
          if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) || (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {
              return false;
          }
      }
      return true;
  };
  
  
  
  /**
   * Makes a checksum address
   *
   * @method toChecksumAddress
   * @param {String} address the given HEX adress
   * @return {String}
  */
  var toChecksumAddress = function (address) {
      if (typeof address === 'undefined') return '';
  
      address = address.toLowerCase().replace('0x','');
      var addressHash = sha3(address);
      var checksumAddress = '0x';
  
      for (var i = 0; i < address.length; i++ ) {
          // If ith character is 9 to f then make it uppercase
          if (parseInt(addressHash[i], 16) > 7) {
            checksumAddress += address[i].toUpperCase();
          } else {
              checksumAddress += address[i];
          }
      }
      return checksumAddress;
  };
  
  /**
   * Transforms given string to valid 20 bytes-length addres with 0x prefix
   *
   * @method toAddress
   * @param {String} address
   * @return {String} formatted address
   */
  var toAddress = function (address) {
      if (isStrictAddress(address)) {
          return address;
      }
  
      if (/^[0-9a-f]{40}$/.test(address)) {
          return '0x' + address;
      }
  
      return '0x' + padLeft(toHex(address).substr(2), 40);
  };
  
  /**
   * Returns true if object is BigNumber, otherwise false
   *
   * @method isBigNumber
   * @param {Object}
   * @return {Boolean}
   */
  var isBigNumber = function (object) {
      return (object && (object instanceof BigNumber || (object.constructor && object.constructor.name === 'BigNumber')));
  };
  
  /**
   * Returns true if object is string, otherwise false
   *
   * @method isString
   * @param {Object}
   * @return {Boolean}
   */
  var isString = function (object) {
      return typeof object === 'string' ||
          (object && object.constructor && object.constructor.name === 'String');
  };
  
  /**
   * Returns true if object is function, otherwise false
   *
   * @method isFunction
   * @param {Object}
   * @return {Boolean}
   */
  var isFunction = function (object) {
      return typeof object === 'function';
  };
  
  /**
   * Returns true if object is Objet, otherwise false
   *
   * @method isObject
   * @param {Object}
   * @return {Boolean}
   */
  var isObject = function (object) {
      return object !== null && !(Array.isArray(object)) && typeof object === 'object';
  };
  
  /**
   * Returns true if object is boolean, otherwise false
   *
   * @method isBoolean
   * @param {Object}
   * @return {Boolean}
   */
  var isBoolean = function (object) {
      return typeof object === 'boolean';
  };
  
  /**
   * Returns true if object is array, otherwise false
   *
   * @method isArray
   * @param {Object}
   * @return {Boolean}
   */
  var isArray = function (object) {
      return Array.isArray(object);
  };
  
  /**
   * Returns true if given string is valid json object
   *
   * @method isJson
   * @param {String}
   * @return {Boolean}
   */
  var isJson = function (str) {
      try {
          return !!JSON.parse(str);
      } catch (e) {
          return false;
      }
  };
  
  /**
   * Returns true if given string is a valid Ethereum block header bloom.
   *
   * @method isBloom
   * @param {String} hex encoded bloom filter
   * @return {Boolean}
   */
  var isBloom = function (bloom) {
      if (!/^(0x)?[0-9a-f]{512}$/i.test(bloom)) {
          return false;
      } else if (/^(0x)?[0-9a-f]{512}$/.test(bloom) || /^(0x)?[0-9A-F]{512}$/.test(bloom)) {
          return true;
      }
      return false;
  };
  
  /**
   * Returns true if given string is a valid log topic.
   *
   * @method isTopic
   * @param {String} hex encoded topic
   * @return {Boolean}
   */
  var isTopic = function (topic) {
      if (!/^(0x)?[0-9a-f]{64}$/i.test(topic)) {
          return false;
      } else if (/^(0x)?[0-9a-f]{64}$/.test(topic) || /^(0x)?[0-9A-F]{64}$/.test(topic)) {
          return true;
      }
      return false;
  };
  
  module.exports = {
      padLeft: padLeft,
      padRight: padRight,
      toHex: toHex,
      toDecimal: toDecimal,
      fromDecimal: fromDecimal,
      toUtf8: toUtf8,
      toAscii: toAscii,
      fromUtf8: fromUtf8,
      fromAscii: fromAscii,
      transformToFullName: transformToFullName,
      extractDisplayName: extractDisplayName,
      extractTypeName: extractTypeName,
      toWei: toWei,
      fromWei: fromWei,
      toBigNumber: toBigNumber,
      toTwosComplement: toTwosComplement,
      toAddress: toAddress,
      isBigNumber: isBigNumber,
      isStrictAddress: isStrictAddress,
      isAddress: isAddress,
      isChecksumAddress: isChecksumAddress,
      toChecksumAddress: toChecksumAddress,
      isFunction: isFunction,
      isString: isString,
      isObject: isObject,
      isBoolean: isBoolean,
      isArray: isArray,
      isJson: isJson,
      isBloom: isBloom,
      isTopic: isTopic,
  };
  
  },{"./sha3.js":19,"bignumber.js":"bignumber.js","utf8":125}],21:[function(require,module,exports){
  module.exports={
      "version": "0.20.7"
  }
  
  },{}],22:[function(require,module,exports){
  /*!
   * web3.js - Ethereum JavaScript API
   *
   * @license lgpl-3.0
   * @see https://github.com/ethereum/web3.js
  */
  
  /*
   * This file is part of web3.js.
   *
   * web3.js is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * web3.js is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
   *
   * @file web3.js
   * @authors:
   *   Jeffrey Wilcke <jeff@ethdev.com>
   *   Marek Kotewicz <marek@ethdev.com>
   *   Marian Oancea <marian@ethdev.com>
   *   Fabian Vogelsteller <fabian@ethdev.com>
   *   Gav Wood <g@ethdev.com>
   * @date 2014
   */
  
  var RequestManager = require('./web4bch/requestmanager');
  var Iban = require('./web4bch/iban');
  var Eth = require('./web4bch/methods/eth');
  var Bch = require('./web4bch/methods/bch');
  var DB = require('./web4bch/methods/db');
  var Shh = require('./web4bch/methods/shh');
  var Net = require('./web4bch/methods/net');
  var Personal = require('./web4bch/methods/personal');
  var Swarm = require('./web4bch/methods/swarm');
  var Debug = require('./web4bch/methods/debug');
  var Settings = require('./web4bch/settings');
  var version = require('./version.json');
  var utils = require('./utils/utils');
  var sha3 = require('./utils/sha3');
  var extend = require('./web4bch/extend');
  var Batch = require('./web4bch/batch');
  var Property = require('./web4bch/property');
  var HttpProvider = require('./web4bch/httpprovider');
  var IpcProvider = require('./web4bch/ipcprovider');
  var BigNumber = require('bignumber.js');
  
  
  
  function Web4Bch (provider) {
      this._requestManager = new RequestManager(provider);
      this.currentProvider = provider;
      this.eth = new Eth(this);
      this.bch = new Bch(this);
      this.db = new DB(this);
      this.shh = new Shh(this);
      this.net = new Net(this);
      this.personal = new Personal(this);
      this.debug = new Debug(this);
      this.bzz = new Swarm(this);
      this.settings = new Settings();
      this.version = {
          api: version.version
      };
      this.providers = {
          HttpProvider: HttpProvider,
          IpcProvider: IpcProvider
      };
      this._extend = extend(this);
      this._extend({
          properties: properties()
      });
  }
  
  // expose providers on the class
  Web4Bch.providers = {
      HttpProvider: HttpProvider,
      IpcProvider: IpcProvider
  };
  
  Web4Bch.prototype.setProvider = function (provider) {
      this._requestManager.setProvider(provider);
      this.currentProvider = provider;
  };
  
  Web4Bch.prototype.reset = function (keepIsSyncing) {
      this._requestManager.reset(keepIsSyncing);
      this.settings = new Settings();
  };
  
  Web4Bch.prototype.BigNumber = BigNumber;
  Web4Bch.prototype.toHex = utils.toHex;
  Web4Bch.prototype.toAscii = utils.toAscii;
  Web4Bch.prototype.toUtf8 = utils.toUtf8;
  Web4Bch.prototype.fromAscii = utils.fromAscii;
  Web4Bch.prototype.fromUtf8 = utils.fromUtf8;
  Web4Bch.prototype.toDecimal = utils.toDecimal;
  Web4Bch.prototype.fromDecimal = utils.fromDecimal;
  Web4Bch.prototype.toBigNumber = utils.toBigNumber;
  Web4Bch.prototype.toWei = utils.toWei;
  Web4Bch.prototype.fromWei = utils.fromWei;
  Web4Bch.prototype.isAddress = utils.isAddress;
  Web4Bch.prototype.isChecksumAddress = utils.isChecksumAddress;
  Web4Bch.prototype.toChecksumAddress = utils.toChecksumAddress;
  Web4Bch.prototype.isIBAN = utils.isIBAN;
  Web4Bch.prototype.padLeft = utils.padLeft;
  Web4Bch.prototype.padRight = utils.padRight;
  
  
  Web4Bch.prototype.sha3 = function(string, options) {
      return '0x' + sha3(string, options);
  };
  
  /**
   * Transforms direct icap to address
   */
  Web4Bch.prototype.fromICAP = function (icap) {
      var iban = new Iban(icap);
      return iban.address();
  };
  
  var properties = function () {
      return [
          new Property({
              name: 'version.node',
              getter: 'web3_clientVersion'
          }),
          new Property({
              name: 'version.network',
              getter: 'net_version',
              inputFormatter: utils.toDecimal
          }),
          new Property({
              name: 'version.ethereum',
              getter: 'eth_protocolVersion',
              inputFormatter: utils.toDecimal
          }),
          new Property({
              name: 'version.whisper',
              getter: 'shh_version',
              inputFormatter: utils.toDecimal
          })
      ];
  };
  
  Web4Bch.prototype.isConnected = function(){
      return (this.currentProvider && this.currentProvider.isConnected());
  };
  
  Web4Bch.prototype.createBatch = function () {
      return new Batch(this);
  };
  
  module.exports = Web4Bch;
  
  },{"./utils/sha3":19,"./utils/utils":20,"./version.json":21,"./web4bch/batch":24,"./web4bch/extend":28,"./web4bch/httpprovider":32,"./web4bch/iban":33,"./web4bch/ipcprovider":34,"./web4bch/methods/bch":37,"./web4bch/methods/db":38,"./web4bch/methods/debug":39,"./web4bch/methods/eth":40,"./web4bch/methods/net":41,"./web4bch/methods/personal":42,"./web4bch/methods/shh":43,"./web4bch/methods/swarm":44,"./web4bch/property":47,"./web4bch/requestmanager":48,"./web4bch/settings":49,"bignumber.js":"bignumber.js"}],23:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file allevents.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2014
   */
  
  var sha3 = require('../utils/sha3');
  var SolidityEvent = require('./event');
  var formatters = require('./formatters');
  var utils = require('../utils/utils');
  var Filter = require('./filter');
  var watches = require('./methods/watches');
  
  var AllSolidityEvents = function (requestManager, json, address) {
      this._requestManager = requestManager;
      this._json = json;
      this._address = address;
  };
  
  AllSolidityEvents.prototype.encode = function (options) {
      options = options || {};
      var result = {};
  
      ['fromBlock', 'toBlock'].filter(function (f) {
          return options[f] !== undefined;
      }).forEach(function (f) {
          result[f] = formatters.inputBlockNumberFormatter(options[f]);
      });
  
      result.address = this._address;
  
      return result;
  };
  
  AllSolidityEvents.prototype.decode = function (data) {
      data.data = data.data || '';
  
  
      var eventTopic = (utils.isArray(data.topics) && utils.isString(data.topics[0])) ? data.topics[0].slice(2) : '';
      var match = this._json.filter(function (j) {
          return eventTopic === sha3(utils.transformToFullName(j));
      })[0];
  
      if (!match) { // cannot find matching event?
          return formatters.outputLogFormatter(data);
      }
  
      var event = new SolidityEvent(this._requestManager, match, this._address);
      return event.decode(data);
  };
  
  AllSolidityEvents.prototype.execute = function (options, callback) {
  
      if (utils.isFunction(arguments[arguments.length - 1])) {
          callback = arguments[arguments.length - 1];
          if(arguments.length === 1)
              options = null;
      }
  
      var o = this.encode(options);
      var formatter = this.decode.bind(this);
      return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback);
  };
  
  AllSolidityEvents.prototype.attachToContract = function (contract) {
      var execute = this.execute.bind(this);
      contract.allEvents = execute;
  };
  
  module.exports = AllSolidityEvents;
  
  
  },{"../utils/sha3":19,"../utils/utils":20,"./event":27,"./filter":29,"./formatters":30,"./methods/watches":45}],24:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file batch.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var Jsonrpc = require('./jsonrpc');
  var errors = require('./errors');
  
  var Batch = function (web3) {
      this.requestManager = web3._requestManager;
      this.requests = [];
  };
  
  /**
   * Should be called to add create new request to batch request
   *
   * @method add
   * @param {Object} jsonrpc requet object
   */
  Batch.prototype.add = function (request) {
      this.requests.push(request);
  };
  
  /**
   * Should be called to execute batch request
   *
   * @method execute
   */
  Batch.prototype.execute = function () {
      var requests = this.requests;
      this.requestManager.sendBatch(requests, function (err, results) {
          results = results || [];
          requests.map(function (request, index) {
              return results[index] || {};
          }).forEach(function (result, index) {
              if (requests[index].callback) {
  
                  if (!Jsonrpc.isValidResponse(result)) {
                      return requests[index].callback(errors.InvalidResponse(result));
                  }
  
                  requests[index].callback(null, (requests[index].format ? requests[index].format(result.result) : result.result));
              }
          });
      }); 
  };
  
  module.exports = Batch;
  
  
  },{"./errors":26,"./jsonrpc":35}],25:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file contract.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2014
   */
  
  var utils = require('../utils/utils');
  var coder = require('../solidity/coder');
  var SolidityEvent = require('./event');
  var SolidityFunction = require('./function');
  var AllEvents = require('./allevents');
  
  /**
   * Should be called to encode constructor params
   *
   * @method encodeConstructorParams
   * @param {Array} abi
   * @param {Array} constructor params
   */
  var encodeConstructorParams = function (abi, params) {
      return abi.filter(function (json) {
          return json.type === 'constructor' && json.inputs.length === params.length;
      }).map(function (json) {
          return json.inputs.map(function (input) {
              return input.type;
          });
      }).map(function (types) {
          return coder.encodeParams(types, params);
      })[0] || '';
  };
  
  /**
   * Should be called to add functions to contract object
   *
   * @method addFunctionsToContract
   * @param {Contract} contract
   * @param {Array} abi
   */
  var addFunctionsToContract = function (contract) {
      contract.abi.filter(function (json) {
          return json.type === 'function';
      }).map(function (json) {
          return new SolidityFunction(contract._eth, json, contract.address);
      }).forEach(function (f) {
          f.attachToContract(contract);
      });
  };
  
  /**
   * Should be called to add events to contract object
   *
   * @method addEventsToContract
   * @param {Contract} contract
   * @param {Array} abi
   */
  var addEventsToContract = function (contract) {
      var events = contract.abi.filter(function (json) {
          return json.type === 'event';
      });
  
      var All = new AllEvents(contract._eth._requestManager, events, contract.address);
      All.attachToContract(contract);
  
      events.map(function (json) {
          return new SolidityEvent(contract._eth._requestManager, json, contract.address);
      }).forEach(function (e) {
          e.attachToContract(contract);
      });
  };
  
  
  /**
   * Should be called to check if the contract gets properly deployed on the blockchain.
   *
   * @method checkForContractAddress
   * @param {Object} contract
   * @param {Function} callback
   * @returns {Undefined}
   */
  var checkForContractAddress = function(contract, callback){
      var count = 0,
          callbackFired = false;
  
      // wait for receipt
      var filter = contract._eth.filter('latest', function(e){
          if (!e && !callbackFired) {
              count++;
  
              // stop watching after 50 blocks (timeout)
              if (count > 50) {
  
                  filter.stopWatching(function() {});
                  callbackFired = true;
  
                  if (callback)
                      callback(new Error('Contract transaction couldn\'t be found after 50 blocks'));
                  else
                      throw new Error('Contract transaction couldn\'t be found after 50 blocks');
  
  
              } else {
  
                  contract._eth.getTransactionReceipt(contract.transactionHash, function(e, receipt){
                      if(receipt && receipt.blockHash && !callbackFired) {
  
                          contract._eth.getCode(receipt.contractAddress, function(e, code){
                              /*jshint maxcomplexity: 6 */
  
                              if(callbackFired || !code)
                                  return;
  
                              filter.stopWatching(function() {});
                              callbackFired = true;
  
                              if(code.length > 3) {
  
                                  // console.log('Contract code deployed!');
  
                                  contract.address = receipt.contractAddress;
  
                                  // attach events and methods again after we have
                                  addFunctionsToContract(contract);
                                  addEventsToContract(contract);
  
                                  // call callback for the second time
                                  if(callback)
                                      callback(null, contract);
  
                              } else {
                                  if(callback)
                                      callback(new Error('The contract code couldn\'t be stored, please check your gas amount.'));
                                  else
                                      throw new Error('The contract code couldn\'t be stored, please check your gas amount.');
                              }
                          });
                      }
                  });
              }
          }
      });
  };
  
  /**
   * Should be called to create new ContractFactory instance
   *
   * @method ContractFactory
   * @param {Array} abi
   */
  var ContractFactory = function (eth, abi) {
      this.eth = eth;
      this.abi = abi;
  
      /**
       * Should be called to create new contract on a blockchain
       *
       * @method new
       * @param {Any} contract constructor param1 (optional)
       * @param {Any} contract constructor param2 (optional)
       * @param {Object} contract transaction object (required)
       * @param {Function} callback
       * @returns {Contract} returns contract instance
       */
      this.new = function () {
          /*jshint maxcomplexity: 7 */
  
          var contract = new Contract(this.eth, this.abi);
  
          // parse arguments
          var options = {}; // required!
          var callback;
  
          var args = Array.prototype.slice.call(arguments);
          if (utils.isFunction(args[args.length - 1])) {
              callback = args.pop();
          }
  
          var last = args[args.length - 1];
          if (utils.isObject(last) && !utils.isArray(last)) {
              options = args.pop();
          }
  
          if (options.value > 0) {
              var constructorAbi = abi.filter(function (json) {
                  return json.type === 'constructor' && json.inputs.length === args.length;
              })[0] || {};
  
              if (!constructorAbi.payable) {
                  throw new Error('Cannot send value to non-payable constructor');
              }
          }
  
          var bytes = encodeConstructorParams(this.abi, args);
          options.data += bytes;
  
          if (callback) {
  
              // wait for the contract address and check if the code was deployed
              this.eth.sendTransaction(options, function (err, hash) {
                  if (err) {
                      callback(err);
                  } else {
                      // add the transaction hash
                      contract.transactionHash = hash;
  
                      // call callback for the first time
                      callback(null, contract);
  
                      checkForContractAddress(contract, callback);
                  }
              });
          } else {
              var hash = this.eth.sendTransaction(options);
              // add the transaction hash
              contract.transactionHash = hash;
              checkForContractAddress(contract);
          }
  
          return contract;
      };
  
      this.new.getData = this.getData.bind(this);
  };
  
  /**
   * Should be called to create new ContractFactory
   *
   * @method contract
   * @param {Array} abi
   * @returns {ContractFactory} new contract factory
   */
  //var contract = function (abi) {
      //return new ContractFactory(abi);
  //};
  
  
  
  /**
   * Should be called to get access to existing contract on a blockchain
   *
   * @method at
   * @param {Address} contract address (required)
   * @param {Function} callback {optional)
   * @returns {Contract} returns contract if no callback was passed,
   * otherwise calls callback function (err, contract)
   */
  ContractFactory.prototype.at = function (address, callback) {
      var contract = new Contract(this.eth, this.abi, address);
  
      // this functions are not part of prototype,
      // because we dont want to spoil the interface
      addFunctionsToContract(contract);
      addEventsToContract(contract);
  
      if (callback) {
          callback(null, contract);
      }
      return contract;
  };
  
  /**
   * Gets the data, which is data to deploy plus constructor params
   *
   * @method getData
   */
  ContractFactory.prototype.getData = function () {
      var options = {}; // required!
      var args = Array.prototype.slice.call(arguments);
  
      var last = args[args.length - 1];
      if (utils.isObject(last) && !utils.isArray(last)) {
          options = args.pop();
      }
  
      var bytes = encodeConstructorParams(this.abi, args);
      options.data += bytes;
  
      return options.data;
  };
  
  /**
   * Should be called to create new contract instance
   *
   * @method Contract
   * @param {Array} abi
   * @param {Address} contract address
   */
  var Contract = function (eth, abi, address) {
      this._eth = eth;
      this.transactionHash = null;
      this.address = address;
      this.abi = abi;
  };
  
  module.exports = ContractFactory;
  
  },{"../solidity/coder":7,"../utils/utils":20,"./allevents":23,"./event":27,"./function":31}],26:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file errors.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  module.exports = {
      InvalidNumberOfSolidityArgs: function () {
          return new Error('Invalid number of arguments to Solidity function');
      },
      InvalidNumberOfRPCParams: function () {
          return new Error('Invalid number of input parameters to RPC method');
      },
      InvalidConnection: function (host){
          return new Error('CONNECTION ERROR: Couldn\'t connect to node '+ host +'.');
      },
      InvalidProvider: function () {
          return new Error('Provider not set or invalid');
      },
      InvalidResponse: function (result){
          var message = !!result && !!result.error && !!result.error.message ? result.error.message : 'Invalid JSON RPC response: ' + JSON.stringify(result);
          return new Error(message);
      },
      ConnectionTimeout: function (ms){
          return new Error('CONNECTION TIMEOUT: timeout of ' + ms + ' ms achieved');
      }
  };
  
  },{}],27:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file event.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2014
   */
  
  var utils = require('../utils/utils');
  var coder = require('../solidity/coder');
  var formatters = require('./formatters');
  var sha3 = require('../utils/sha3');
  var Filter = require('./filter');
  var watches = require('./methods/watches');
  
  /**
   * This prototype should be used to create event filters
   */
  var SolidityEvent = function (requestManager, json, address) {
      this._requestManager = requestManager;
      this._params = json.inputs;
      this._name = utils.transformToFullName(json);
      this._address = address;
      this._anonymous = json.anonymous;
  };
  
  /**
   * Should be used to get filtered param types
   *
   * @method types
   * @param {Bool} decide if returned typed should be indexed
   * @return {Array} array of types
   */
  SolidityEvent.prototype.types = function (indexed) {
      return this._params.filter(function (i) {
          return i.indexed === indexed;
      }).map(function (i) {
          return i.type;
      });
  };
  
  /**
   * Should be used to get event display name
   *
   * @method displayName
   * @return {String} event display name
   */
  SolidityEvent.prototype.displayName = function () {
      return utils.extractDisplayName(this._name);
  };
  
  /**
   * Should be used to get event type name
   *
   * @method typeName
   * @return {String} event type name
   */
  SolidityEvent.prototype.typeName = function () {
      return utils.extractTypeName(this._name);
  };
  
  /**
   * Should be used to get event signature
   *
   * @method signature
   * @return {String} event signature
   */
  SolidityEvent.prototype.signature = function () {
      return sha3(this._name);
  };
  
  /**
   * Should be used to encode indexed params and options to one final object
   *
   * @method encode
   * @param {Object} indexed
   * @param {Object} options
   * @return {Object} everything combined together and encoded
   */
  SolidityEvent.prototype.encode = function (indexed, options) {
      indexed = indexed || {};
      options = options || {};
      var result = {};
  
      ['fromBlock', 'toBlock'].filter(function (f) {
          return options[f] !== undefined;
      }).forEach(function (f) {
          result[f] = formatters.inputBlockNumberFormatter(options[f]);
      });
  
      result.topics = [];
  
      result.address = this._address;
      if (!this._anonymous) {
          result.topics.push('0x' + this.signature());
      }
  
      var indexedTopics = this._params.filter(function (i) {
          return i.indexed === true;
      }).map(function (i) {
          var value = indexed[i.name];
          if (value === undefined || value === null) {
              return null;
          }
  
          if (utils.isArray(value)) {
              return value.map(function (v) {
                  return '0x' + coder.encodeParam(i.type, v);
              });
          }
          return '0x' + coder.encodeParam(i.type, value);
      });
  
      result.topics = result.topics.concat(indexedTopics);
  
      return result;
  };
  
  /**
   * Should be used to decode indexed params and options
   *
   * @method decode
   * @param {Object} data
   * @return {Object} result object with decoded indexed && not indexed params
   */
  SolidityEvent.prototype.decode = function (data) {
  
      data.data = data.data || '';
      data.topics = data.topics || [];
  
  
      var argTopics = this._anonymous ? data.topics : data.topics.slice(1);
      var indexedData = argTopics.map(function (topics) { return topics.slice(2); }).join("");
      var indexedParams = coder.decodeParams(this.types(true), indexedData);
  
      var notIndexedData = data.data.slice(2);
      var notIndexedParams = coder.decodeParams(this.types(false), notIndexedData);
  
      var result = formatters.outputLogFormatter(data);
      result.event = this.displayName();
      result.address = data.address;
  
      result.args = this._params.reduce(function (acc, current) {
          acc[current.name] = current.indexed ? indexedParams.shift() : notIndexedParams.shift();
          return acc;
      }, {});
  
      delete result.data;
      delete result.topics;
  
      return result;
  };
  
  /**
   * Should be used to create new filter object from event
   *
   * @method execute
   * @param {Object} indexed
   * @param {Object} options
   * @return {Object} filter object
   */
  SolidityEvent.prototype.execute = function (indexed, options, callback) {
  
      if (utils.isFunction(arguments[arguments.length - 1])) {
          callback = arguments[arguments.length - 1];
          if(arguments.length === 2)
              options = null;
          if(arguments.length === 1) {
              options = null;
              indexed = {};
          }
      }
  
      var o = this.encode(indexed, options);
      var formatter = this.decode.bind(this);
      return new Filter(o, 'eth', this._requestManager, watches.eth(), formatter, callback);
  };
  
  /**
   * Should be used to attach event to contract object
   *
   * @method attachToContract
   * @param {Contract}
   */
  SolidityEvent.prototype.attachToContract = function (contract) {
      var execute = this.execute.bind(this);
      var displayName = this.displayName();
      if (!contract[displayName]) {
          contract[displayName] = execute;
      }
      contract[displayName][this.typeName()] = this.execute.bind(this, contract);
  };
  
  module.exports = SolidityEvent;
  
  
  },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./filter":29,"./formatters":30,"./methods/watches":45}],28:[function(require,module,exports){
  var formatters = require('./formatters');
  var utils = require('./../utils/utils');
  var Method = require('./method');
  var Property = require('./property');
  
  // TODO: refactor, so the input params are not altered.
  // it's necessary to make same 'extension' work with multiple providers
  var extend = function (web3) {
      /* jshint maxcomplexity:5 */
      var ex = function (extension) {
  
          var extendedObject;
          if (extension.property) {
              if (!web3[extension.property]) {
                  web3[extension.property] = {};
              }
              extendedObject = web3[extension.property];
          } else {
              extendedObject = web3;
          }
  
          if (extension.methods) {
              extension.methods.forEach(function (method) {
                  method.attachToObject(extendedObject);
                  method.setRequestManager(web3._requestManager);
              });
          }
  
          if (extension.properties) {
              extension.properties.forEach(function (property) {
                  property.attachToObject(extendedObject);
                  property.setRequestManager(web3._requestManager);
              });
          }
      };
  
      ex.formatters = formatters; 
      ex.utils = utils;
      ex.Method = Method;
      ex.Property = Property;
  
      return ex;
  };
  
  
  
  module.exports = extend;
  
  
  },{"./../utils/utils":20,"./formatters":30,"./method":36,"./property":47}],29:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file filter.js
   * @authors:
   *   Jeffrey Wilcke <jeff@ethdev.com>
   *   Marek Kotewicz <marek@ethdev.com>
   *   Marian Oancea <marian@ethdev.com>
   *   Fabian Vogelsteller <fabian@ethdev.com>
   *   Gav Wood <g@ethdev.com>
   * @date 2014
   */
  
  var formatters = require('./formatters');
  var utils = require('../utils/utils');
  
  /**
  * Converts a given topic to a hex string, but also allows null values.
  *
  * @param {Mixed} value
  * @return {String}
  */
  var toTopic = function(value){
  
      if(value === null || typeof value === 'undefined')
          return null;
  
      value = String(value);
  
      if(value.indexOf('0x') === 0)
          return value;
      else
          return utils.fromUtf8(value);
  };
  
  /// This method should be called on options object, to verify deprecated properties && lazy load dynamic ones
  /// @param should be string or object
  /// @returns options string or object
  var getOptions = function (options, type) {
      /*jshint maxcomplexity: 6 */
  
      if (utils.isString(options)) {
          return options;
      }
  
      options = options || {};
  
  
      switch(type) {
          case 'eth':
  
              // make sure topics, get converted to hex
              options.topics = options.topics || [];
              options.topics = options.topics.map(function(topic){
                  return (utils.isArray(topic)) ? topic.map(toTopic) : toTopic(topic);
              });
  
              return {
                  topics: options.topics,
                  from: options.from,
                  to: options.to,
                  address: options.address,
                  fromBlock: formatters.inputBlockNumberFormatter(options.fromBlock),
                  toBlock: formatters.inputBlockNumberFormatter(options.toBlock)
              };
          case 'shh':
              return options;
      }
  };
  
  /**
  Adds the callback and sets up the methods, to iterate over the results.
  
  @method getLogsAtStart
  @param {Object} self
  @param {function} callback
  */
  var getLogsAtStart = function(self, callback){
      // call getFilterLogs for the first watch callback start
      if (!utils.isString(self.options)) {
          self.get(function (err, messages) {
              // don't send all the responses to all the watches again... just to self one
              if (err) {
                  callback(err);
              }
  
              if(utils.isArray(messages)) {
                  messages.forEach(function (message) {
                      callback(null, message);
                  });
              }
          });
      }
  };
  
  /**
  Adds the callback and sets up the methods, to iterate over the results.
  
  @method pollFilter
  @param {Object} self
  */
  var pollFilter = function(self) {
  
      var onMessage = function (error, messages) {
          if (error) {
              return self.callbacks.forEach(function (callback) {
                  callback(error);
              });
          }
  
          if(utils.isArray(messages)) {
              messages.forEach(function (message) {
                  message = self.formatter ? self.formatter(message) : message;
                  self.callbacks.forEach(function (callback) {
                      callback(null, message);
                  });
              });
          }
      };
  
      self.requestManager.startPolling({
          method: self.implementation.poll.call,
          params: [self.filterId],
      }, self.filterId, onMessage, self.stopWatching.bind(self));
  
  };
  
  var Filter = function (options, type, requestManager, methods, formatter, callback, filterCreationErrorCallback) {
      var self = this;
      var implementation = {};
      methods.forEach(function (method) {
          method.setRequestManager(requestManager);
          method.attachToObject(implementation);
      });
      this.requestManager = requestManager;
      this.options = getOptions(options, type);
      this.implementation = implementation;
      this.filterId = null;
      this.callbacks = [];
      this.getLogsCallbacks = [];
      this.pollFilters = [];
      this.formatter = formatter;
      this.implementation.newFilter(this.options, function(error, id){
          if(error) {
              self.callbacks.forEach(function(cb){
                  cb(error);
              });
              if (typeof filterCreationErrorCallback === 'function') {
                filterCreationErrorCallback(error);
              }
          } else {
              self.filterId = id;
  
              // check if there are get pending callbacks as a consequence
              // of calling get() with filterId unassigned.
              self.getLogsCallbacks.forEach(function (cb){
                  self.get(cb);
              });
              self.getLogsCallbacks = [];
  
              // get filter logs for the already existing watch calls
              self.callbacks.forEach(function(cb){
                  getLogsAtStart(self, cb);
              });
              if(self.callbacks.length > 0)
                  pollFilter(self);
  
              // start to watch immediately
              if(typeof callback === 'function') {
                  return self.watch(callback);
              }
          }
      });
  
      return this;
  };
  
  Filter.prototype.watch = function (callback) {
      this.callbacks.push(callback);
  
      if(this.filterId) {
          getLogsAtStart(this, callback);
          pollFilter(this);
      }
  
      return this;
  };
  
  Filter.prototype.stopWatching = function (callback) {
      this.requestManager.stopPolling(this.filterId);
      this.callbacks = [];
      // remove filter async
      if (callback) {
          this.implementation.uninstallFilter(this.filterId, callback);
      } else {
          return this.implementation.uninstallFilter(this.filterId);
      }
  };
  
  Filter.prototype.get = function (callback) {
      var self = this;
      if (utils.isFunction(callback)) {
          if (this.filterId === null) {
              // If filterId is not set yet, call it back
              // when newFilter() assigns it.
              this.getLogsCallbacks.push(callback);
          } else {
              this.implementation.getLogs(this.filterId, function(err, res){
                  if (err) {
                      callback(err);
                  } else {
                      callback(null, res.map(function (log) {
                          return self.formatter ? self.formatter(log) : log;
                      }));
                  }
              });
          }
      } else {
          if (this.filterId === null) {
              throw new Error('Filter ID Error: filter().get() can\'t be chained synchronous, please provide a callback for the get() method.');
          }
          var logs = this.implementation.getLogs(this.filterId);
          return logs.map(function (log) {
              return self.formatter ? self.formatter(log) : log;
          });
      }
  
      return this;
  };
  
  module.exports = Filter;
  
  
  },{"../utils/utils":20,"./formatters":30}],30:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file formatters.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @author Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  'use strict';
  
  
  var utils = require('../utils/utils');
  var config = require('../utils/config');
  var Iban = require('./iban');
  
  /**
   * Should the format output to a big number
   *
   * @method outputBigNumberFormatter
   * @param {String|Number|BigNumber}
   * @returns {BigNumber} object
   */
  var outputBigNumberFormatter = function (number) {
      return utils.toBigNumber(number);
  };
  
  var isPredefinedBlockNumber = function (blockNumber) {
      return blockNumber === 'latest' || blockNumber === 'pending' || blockNumber === 'earliest';
  };
  
  var inputDefaultBlockNumberFormatter = function (blockNumber) {
      if (blockNumber === undefined) {
          return config.defaultBlock;
      }
      return inputBlockNumberFormatter(blockNumber);
  };
  
  var inputBlockNumberFormatter = function (blockNumber) {
      if (blockNumber === undefined) {
          return undefined;
      } else if (isPredefinedBlockNumber(blockNumber)) {
          return blockNumber;
      }
      return utils.toHex(blockNumber);
  };
  
  /**
   * Formats the input of a transaction and converts all values to HEX
   *
   * @method inputCallFormatter
   * @param {Object} transaction options
   * @returns object
  */
  var inputCallFormatter = function (options){
  
      options.from = options.from || config.defaultAccount;
  
      if (options.from) {
          options.from = inputAddressFormatter(options.from);
      }
  
      if (options.to) { // it might be contract creation
          options.to = inputAddressFormatter(options.to);
      }
  
      ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
          return options[key] !== undefined;
      }).forEach(function(key){
          options[key] = utils.fromDecimal(options[key]);
      });
  
      return options;
  };
  
  /**
   * Formats the input of a transaction and converts all values to HEX
   *
   * @method inputTransactionFormatter
   * @param {Object} transaction options
   * @returns object
  */
  var inputTransactionFormatter = function (options){
  
      options.from = options.from || config.defaultAccount;
      options.from = inputAddressFormatter(options.from);
  
      if (options.to) { // it might be contract creation
          options.to = inputAddressFormatter(options.to);
      }
  
      ['gasPrice', 'gas', 'value', 'nonce'].filter(function (key) {
          return options[key] !== undefined;
      }).forEach(function(key){
          options[key] = utils.fromDecimal(options[key]);
      });
  
      return options;
  };
  
  /**
   * Formats the input of the eth_getLogs command
   *
   * @method inputGetLogsFormatter
   * @param {Object} getLogs options
   * @returns {Object}
   */
  var inputGetLogsFormatter = function (options) {
      if (options.fromBlock)
          options.fromBlock = inputBlockNumberFormatter(options.fromBlock);
      if (options.toBlock)
          options.toBlock = inputBlockNumberFormatter(options.toBlock);
  };
  
  /**
   * Formats the output of a transaction to its proper values
   *
   * @method outputTransactionFormatter
   * @param {Object} tx
   * @returns {Object}
  */
  var outputTransactionFormatter = function (tx){
      if(tx.blockNumber !== null)
          tx.blockNumber = utils.toDecimal(tx.blockNumber);
      if(tx.transactionIndex !== null)
          tx.transactionIndex = utils.toDecimal(tx.transactionIndex);
      tx.nonce = utils.toDecimal(tx.nonce);
      tx.gas = utils.toDecimal(tx.gas);
      tx.gasPrice = utils.toBigNumber(tx.gasPrice);
      tx.value = utils.toBigNumber(tx.value);
      return tx;
  };
  
  /**
   * Formats the output of a transaction receipt to its proper values
   *
   * @method outputTransactionReceiptFormatter
   * @param {Object} receipt
   * @returns {Object}
  */
  var outputTransactionReceiptFormatter = function (receipt){
      if(receipt.blockNumber !== null)
          receipt.blockNumber = utils.toDecimal(receipt.blockNumber);
      if(receipt.transactionIndex !== null)
          receipt.transactionIndex = utils.toDecimal(receipt.transactionIndex);
      receipt.cumulativeGasUsed = utils.toDecimal(receipt.cumulativeGasUsed);
      receipt.gasUsed = utils.toDecimal(receipt.gasUsed);
  
      if(utils.isArray(receipt.logs)) {
          receipt.logs = receipt.logs.map(function(log){
              return outputLogFormatter(log);
          });
      }
  
      return receipt;
  };
  
  /**
   * Formats the output of a block to its proper values
   *
   * @method outputBlockFormatter
   * @param {Object} block
   * @returns {Object}
  */
  var outputBlockFormatter = function(block) {
  
      // transform to number
      block.gasLimit = utils.toDecimal(block.gasLimit);
      block.gasUsed = utils.toDecimal(block.gasUsed);
      block.size = utils.toDecimal(block.size);
      block.timestamp = utils.toDecimal(block.timestamp);
      if(block.number !== null)
          block.number = utils.toDecimal(block.number);
  
      block.difficulty = utils.toBigNumber(block.difficulty);
      block.totalDifficulty = utils.toBigNumber(block.totalDifficulty);
  
      if (utils.isArray(block.transactions)) {
          block.transactions.forEach(function(item){
              if(!utils.isString(item))
                  return outputTransactionFormatter(item);
          });
      }
  
      return block;
  };
  
  /**
   * Formats the output of a log
   *
   * @method outputLogFormatter
   * @param {Object} log object
   * @returns {Object} log
  */
  var outputLogFormatter = function(log) {
      if(log.blockNumber)
          log.blockNumber = utils.toDecimal(log.blockNumber);
      if(log.transactionIndex)
          log.transactionIndex = utils.toDecimal(log.transactionIndex);
      if(log.logIndex)
          log.logIndex = utils.toDecimal(log.logIndex);
  
      return log;
  };
  
  /**
   * Formats the input of a whisper post and converts all values to HEX
   *
   * @method inputPostFormatter
   * @param {Object} transaction object
   * @returns {Object}
  */
  var inputPostFormatter = function(post) {
  
      // post.payload = utils.toHex(post.payload);
      post.ttl = utils.fromDecimal(post.ttl);
      post.workToProve = utils.fromDecimal(post.workToProve);
      post.priority = utils.fromDecimal(post.priority);
  
      // fallback
      if (!utils.isArray(post.topics)) {
          post.topics = post.topics ? [post.topics] : [];
      }
  
      // format the following options
      post.topics = post.topics.map(function(topic){
          // convert only if not hex
          return (topic.indexOf('0x') === 0) ? topic : utils.fromUtf8(topic);
      });
  
      return post;
  };
  
  /**
   * Formats the output of a received post message
   *
   * @method outputPostFormatter
   * @param {Object}
   * @returns {Object}
   */
  var outputPostFormatter = function(post){
  
      post.expiry = utils.toDecimal(post.expiry);
      post.sent = utils.toDecimal(post.sent);
      post.ttl = utils.toDecimal(post.ttl);
      post.workProved = utils.toDecimal(post.workProved);
      // post.payloadRaw = post.payload;
      // post.payload = utils.toAscii(post.payload);
  
      // if (utils.isJson(post.payload)) {
      //     post.payload = JSON.parse(post.payload);
      // }
  
      // format the following options
      if (!post.topics) {
          post.topics = [];
      }
      post.topics = post.topics.map(function(topic){
          return utils.toAscii(topic);
      });
  
      return post;
  };
  
  var inputAddressFormatter = function (address) {
      var iban = new Iban(address);
      if (iban.isValid() && iban.isDirect()) {
          return '0x' + iban.address();
      } else if (utils.isStrictAddress(address)) {
          return address;
      } else if (utils.isAddress(address)) {
          return '0x' + address;
      }
      throw new Error('invalid address');
  };
  
  
  var outputSyncingFormatter = function(result) {
      if (!result) {
          return result;
      }
  
      result.startingBlock = utils.toDecimal(result.startingBlock);
      result.currentBlock = utils.toDecimal(result.currentBlock);
      result.highestBlock = utils.toDecimal(result.highestBlock);
      if (result.knownStates) {
          result.knownStates = utils.toDecimal(result.knownStates);
          result.pulledStates = utils.toDecimal(result.pulledStates);
      }
  
      return result;
  };
  
  module.exports = {
      inputDefaultBlockNumberFormatter: inputDefaultBlockNumberFormatter,
      inputBlockNumberFormatter: inputBlockNumberFormatter,
      inputCallFormatter: inputCallFormatter,
      inputTransactionFormatter: inputTransactionFormatter,
      inputAddressFormatter: inputAddressFormatter,
      inputPostFormatter: inputPostFormatter,
      inputGetLogsFormatter: inputGetLogsFormatter,
      outputBigNumberFormatter: outputBigNumberFormatter,
      outputTransactionFormatter: outputTransactionFormatter,
      outputTransactionReceiptFormatter: outputTransactionReceiptFormatter,
      outputBlockFormatter: outputBlockFormatter,
      outputLogFormatter: outputLogFormatter,
      outputPostFormatter: outputPostFormatter,
      outputSyncingFormatter: outputSyncingFormatter
  };
  
  
  },{"../utils/config":18,"../utils/utils":20,"./iban":33}],31:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file function.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var coder = require('../solidity/coder');
  var utils = require('../utils/utils');
  var errors = require('./errors');
  var formatters = require('./formatters');
  var sha3 = require('../utils/sha3');
  
  /**
   * This prototype should be used to call/sendTransaction to solidity functions
   */
  var SolidityFunction = function (eth, json, address) {
      this._eth = eth;
      this._inputTypes = json.inputs.map(function (i) {
          return i.type;
      });
      this._outputTypes = json.outputs.map(function (i) {
          return i.type;
      });
      this._constant = (json.stateMutability === "view" || json.stateMutability === "pure" || json.constant);
      this._payable = (json.stateMutability === "payable" || json.payable);
      this._name = utils.transformToFullName(json);
      this._address = address;
  };
  
  SolidityFunction.prototype.extractCallback = function (args) {
      if (utils.isFunction(args[args.length - 1])) {
          return args.pop(); // modify the args array!
      }
  };
  
  SolidityFunction.prototype.extractDefaultBlock = function (args) {
      if (args.length > this._inputTypes.length && !utils.isObject(args[args.length -1])) {
          return formatters.inputDefaultBlockNumberFormatter(args.pop()); // modify the args array!
      }
  };
  
  /**
   * Should be called to check if the number of arguments is correct
   *
   * @method validateArgs
   * @param {Array} arguments
   * @throws {Error} if it is not
   */
  SolidityFunction.prototype.validateArgs = function (args) {
      var inputArgs = args.filter(function (a) {
        // filter the options object but not arguments that are arrays
        return !( (utils.isObject(a) === true) &&
                  (utils.isArray(a) === false) &&
                  (utils.isBigNumber(a) === false)
                );
      });
      if (inputArgs.length !== this._inputTypes.length) {
          throw errors.InvalidNumberOfSolidityArgs();
      }
  };
  
  /**
   * Should be used to create payload from arguments
   *
   * @method toPayload
   * @param {Array} solidity function params
   * @param {Object} optional payload options
   */
  SolidityFunction.prototype.toPayload = function (args) {
      var options = {};
      if (args.length > this._inputTypes.length && utils.isObject(args[args.length -1])) {
          options = args[args.length - 1];
      }
      this.validateArgs(args);
      options.to = this._address;
      options.data = '0x' + this.signature() + coder.encodeParams(this._inputTypes, args);
      return options;
  };
  
  /**
   * Should be used to get function signature
   *
   * @method signature
   * @return {String} function signature
   */
  SolidityFunction.prototype.signature = function () {
      return sha3(this._name).slice(0, 8);
  };
  
  
  SolidityFunction.prototype.unpackOutput = function (output) {
      if (!output) {
          return;
      }
  
      output = output.length >= 2 ? output.slice(2) : output;
      var result = coder.decodeParams(this._outputTypes, output);
      return result.length === 1 ? result[0] : result;
  };
  
  /**
   * Calls a contract function.
   *
   * @method call
   * @param {...Object} Contract function arguments
   * @param {function} If the last argument is a function, the contract function
   *   call will be asynchronous, and the callback will be passed the
   *   error and result.
   * @return {String} output bytes
   */
  SolidityFunction.prototype.call = function () {
      var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; });
      var callback = this.extractCallback(args);
      var defaultBlock = this.extractDefaultBlock(args);
      var payload = this.toPayload(args);
  
  
      if (!callback) {
          var output = this._eth.call(payload, defaultBlock);
          return this.unpackOutput(output);
      }
  
      var self = this;
      this._eth.call(payload, defaultBlock, function (error, output) {
          if (error) return callback(error, null);
  
          var unpacked = null;
          try {
              unpacked = self.unpackOutput(output);
          }
          catch (e) {
              error = e;
          }
  
          callback(error, unpacked);
      });
  };
  
  /**
   * Should be used to sendTransaction to solidity function
   *
   * @method sendTransaction
   */
  SolidityFunction.prototype.sendTransaction = function () {
      var args = Array.prototype.slice.call(arguments).filter(function (a) {return a !== undefined; });
      var callback = this.extractCallback(args);
      var payload = this.toPayload(args);
  
      if (payload.value > 0 && !this._payable) {
          throw new Error('Cannot send value to non-payable function');
      }
  
      if (!callback) {
          return this._eth.sendTransaction(payload);
      }
  
      this._eth.sendTransaction(payload, callback);
  };
  
  /**
   * Should be used to estimateGas of solidity function
   *
   * @method estimateGas
   */
  SolidityFunction.prototype.estimateGas = function () {
      var args = Array.prototype.slice.call(arguments);
      var callback = this.extractCallback(args);
      var payload = this.toPayload(args);
  
      if (!callback) {
          return this._eth.estimateGas(payload);
      }
  
      this._eth.estimateGas(payload, callback);
  };
  
  /**
   * Return the encoded data of the call
   *
   * @method getData
   * @return {String} the encoded data
   */
  SolidityFunction.prototype.getData = function () {
      var args = Array.prototype.slice.call(arguments);
      var payload = this.toPayload(args);
  
      return payload.data;
  };
  
  /**
   * Should be used to get function display name
   *
   * @method displayName
   * @return {String} display name of the function
   */
  SolidityFunction.prototype.displayName = function () {
      return utils.extractDisplayName(this._name);
  };
  
  /**
   * Should be used to get function type name
   *
   * @method typeName
   * @return {String} type name of the function
   */
  SolidityFunction.prototype.typeName = function () {
      return utils.extractTypeName(this._name);
  };
  
  /**
   * Should be called to get rpc requests from solidity function
   *
   * @method request
   * @returns {Object}
   */
  SolidityFunction.prototype.request = function () {
      var args = Array.prototype.slice.call(arguments);
      var callback = this.extractCallback(args);
      var payload = this.toPayload(args);
      var format = this.unpackOutput.bind(this);
  
      return {
          method: this._constant ? 'eth_call' : 'eth_sendTransaction',
          callback: callback,
          params: [payload],
          format: format
      };
  };
  
  /**
   * Should be called to execute function
   *
   * @method execute
   */
  SolidityFunction.prototype.execute = function () {
      var transaction = !this._constant;
  
      // send transaction
      if (transaction) {
          return this.sendTransaction.apply(this, Array.prototype.slice.call(arguments));
      }
  
      // call
      return this.call.apply(this, Array.prototype.slice.call(arguments));
  };
  
  /**
   * Should be called to attach function to contract
   *
   * @method attachToContract
   * @param {Contract}
   */
  SolidityFunction.prototype.attachToContract = function (contract) {
      var execute = this.execute.bind(this);
      execute.request = this.request.bind(this);
      execute.call = this.call.bind(this);
      execute.sendTransaction = this.sendTransaction.bind(this);
      execute.estimateGas = this.estimateGas.bind(this);
      execute.getData = this.getData.bind(this);
      var displayName = this.displayName();
      if (!contract[displayName]) {
          contract[displayName] = execute;
      }
      contract[displayName][this.typeName()] = execute; // circular!!!!
  };
  
  module.exports = SolidityFunction;
  
  },{"../solidity/coder":7,"../utils/sha3":19,"../utils/utils":20,"./errors":26,"./formatters":30}],32:[function(require,module,exports){
  (function (Buffer){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file httpprovider.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   *   Marian Oancea <marian@ethdev.com>
   *   Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  var errors = require('./errors');
  
  // workaround to use httpprovider in different envs
  
  // browser
  if (typeof window !== 'undefined' && window.XMLHttpRequest) {
    XMLHttpRequest = window.XMLHttpRequest; // jshint ignore: line
  // node
  } else {
    XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest; // jshint ignore: line
  }
  
  var XHR2 = require('xhr2-cookies').XMLHttpRequest; // jshint ignore: line
  
  /**
   * HttpProvider should be used to send rpc calls over http
   */
  var HttpProvider = function (host, timeout, user, password, headers) {
    this.host = host || 'http://localhost:8545';
    this.timeout = timeout || 0;
    this.user = user;
    this.password = password;
    this.headers = headers;
  };
  
  /**
   * Should be called to prepare new XMLHttpRequest
   *
   * @method prepareRequest
   * @param {Boolean} true if request should be async
   * @return {XMLHttpRequest} object
   */
  HttpProvider.prototype.prepareRequest = function (async) {
    var request;
  
    if (async) {
      request = new XHR2();
      request.timeout = this.timeout;
    } else {
      request = new XMLHttpRequest();
    }
    request.withCredentials = true;
  
    request.open('POST', this.host, async);
    if (this.user && this.password) {
      var auth = 'Basic ' + new Buffer(this.user + ':' + this.password).toString('base64');
      request.setRequestHeader('Authorization', auth);
    } request.setRequestHeader('Content-Type', 'application/json');
    if(this.headers) {
        this.headers.forEach(function(header) {
            request.setRequestHeader(header.name, header.value);
        });
    }
    return request;
  };
  
  /**
   * Should be called to make sync request
   *
   * @method send
   * @param {Object} payload
   * @return {Object} result
   */
  HttpProvider.prototype.send = function (payload) {
    var request = this.prepareRequest(false);
  
    try {
      request.send(JSON.stringify(payload));
    } catch (error) {
      throw errors.InvalidConnection(this.host);
    }
  
    var result = request.responseText;
  
    try {
      result = JSON.parse(result);
    } catch (e) {
      throw errors.InvalidResponse(request.responseText);
    }
  
    return result;
  };
  
  /**
   * Should be used to make async request
   *
   * @method sendAsync
   * @param {Object} payload
   * @param {Function} callback triggered on end with (err, result)
   * @return {XMLHttpRequest} object
   */
  HttpProvider.prototype.sendAsync = function (payload, callback) {
    var request = this.prepareRequest(true);
  
    request.onreadystatechange = function () {
      if (request.readyState === 4 && request.timeout !== 1) {
        var result = request.responseText;
        var error = null;
  
        try {
          result = JSON.parse(result);
        } catch (e) {
          error = errors.InvalidResponse(request.responseText);
        }
  
        callback(error, result);
      }
    };
  
    request.ontimeout = function () {
      callback(errors.ConnectionTimeout(this.timeout));
    };
  
    try {
      request.send(JSON.stringify(payload));
    } catch (error) {
      callback(errors.InvalidConnection(this.host));
    }
    return request;
  };
  
  /**
   * Synchronously tries to make Http request
   *
   * @method isConnected
   * @return {Boolean} returns true if request haven't failed. Otherwise false
   */
  HttpProvider.prototype.isConnected = function () {
    try {
      this.send({
        id: 9999999999,
        jsonrpc: '2.0',
        method: 'net_listening',
        params: []
      });
      return true;
    } catch (e) {
      return false;
    }
  };
  
  module.exports = HttpProvider;
  
  }).call(this,require("buffer").Buffer)
  
  },{"./errors":26,"buffer":55,"xhr2-cookies":128,"xmlhttprequest":17}],33:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file iban.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var BigNumber = require('bignumber.js');
  
  var padLeft = function (string, bytes) {
      var result = string;
      while (result.length < bytes * 2) {
          result = '0' + result;
      }
      return result;
  };
  
  /**
   * Prepare an IBAN for mod 97 computation by moving the first 4 chars to the end and transforming the letters to
   * numbers (A = 10, B = 11, ..., Z = 35), as specified in ISO13616.
   *
   * @method iso13616Prepare
   * @param {String} iban the IBAN
   * @returns {String} the prepared IBAN
   */
  var iso13616Prepare = function (iban) {
      var A = 'A'.charCodeAt(0);
      var Z = 'Z'.charCodeAt(0);
  
      iban = iban.toUpperCase();
      iban = iban.substr(4) + iban.substr(0,4);
  
      return iban.split('').map(function(n){
          var code = n.charCodeAt(0);
          if (code >= A && code <= Z){
              // A = 10, B = 11, ... Z = 35
              return code - A + 10;
          } else {
              return n;
          }
      }).join('');
  };
  
  /**
   * Calculates the MOD 97 10 of the passed IBAN as specified in ISO7064.
   *
   * @method mod9710
   * @param {String} iban
   * @returns {Number}
   */
  var mod9710 = function (iban) {
      var remainder = iban,
          block;
  
      while (remainder.length > 2){
          block = remainder.slice(0, 9);
          remainder = parseInt(block, 10) % 97 + remainder.slice(block.length);
      }
  
      return parseInt(remainder, 10) % 97;
  };
  
  /**
   * This prototype should be used to create iban object from iban correct string
   *
   * @param {String} iban
   */
  var Iban = function (iban) {
      this._iban = iban;
  };
  
  /**
   * This method should be used to create iban object from ethereum address
   *
   * @method fromAddress
   * @param {String} address
   * @return {Iban} the IBAN object
   */
  Iban.fromAddress = function (address) {
      var asBn = new BigNumber(address, 16);
      var base36 = asBn.toString(36);
      var padded = padLeft(base36, 15);
      return Iban.fromBban(padded.toUpperCase());
  };
  
  /**
   * Convert the passed BBAN to an IBAN for this country specification.
   * Please note that <i>"generation of the IBAN shall be the exclusive responsibility of the bank/branch servicing the account"</i>.
   * This method implements the preferred algorithm described in http://en.wikipedia.org/wiki/International_Bank_Account_Number#Generating_IBAN_check_digits
   *
   * @method fromBban
   * @param {String} bban the BBAN to convert to IBAN
   * @returns {Iban} the IBAN object
   */
  Iban.fromBban = function (bban) {
      var countryCode = 'XE';
  
      var remainder = mod9710(iso13616Prepare(countryCode + '00' + bban));
      var checkDigit = ('0' + (98 - remainder)).slice(-2);
  
      return new Iban(countryCode + checkDigit + bban);
  };
  
  /**
   * Should be used to create IBAN object for given institution and identifier
   *
   * @method createIndirect
   * @param {Object} options, required options are "institution" and "identifier"
   * @return {Iban} the IBAN object
   */
  Iban.createIndirect = function (options) {
      return Iban.fromBban('ETH' + options.institution + options.identifier);
  };
  
  /**
   * Thos method should be used to check if given string is valid iban object
   *
   * @method isValid
   * @param {String} iban string
   * @return {Boolean} true if it is valid IBAN
   */
  Iban.isValid = function (iban) {
      var i = new Iban(iban);
      return i.isValid();
  };
  
  /**
   * Should be called to check if iban is correct
   *
   * @method isValid
   * @returns {Boolean} true if it is, otherwise false
   */
  Iban.prototype.isValid = function () {
      return /^XE[0-9]{2}(ETH[0-9A-Z]{13}|[0-9A-Z]{30,31})$/.test(this._iban) &&
          mod9710(iso13616Prepare(this._iban)) === 1;
  };
  
  /**
   * Should be called to check if iban number is direct
   *
   * @method isDirect
   * @returns {Boolean} true if it is, otherwise false
   */
  Iban.prototype.isDirect = function () {
      return this._iban.length === 34 || this._iban.length === 35;
  };
  
  /**
   * Should be called to check if iban number if indirect
   *
   * @method isIndirect
   * @returns {Boolean} true if it is, otherwise false
   */
  Iban.prototype.isIndirect = function () {
      return this._iban.length === 20;
  };
  
  /**
   * Should be called to get iban checksum
   * Uses the mod-97-10 checksumming protocol (ISO/IEC 7064:2003)
   *
   * @method checksum
   * @returns {String} checksum
   */
  Iban.prototype.checksum = function () {
      return this._iban.substr(2, 2);
  };
  
  /**
   * Should be called to get institution identifier
   * eg. XREG
   *
   * @method institution
   * @returns {String} institution identifier
   */
  Iban.prototype.institution = function () {
      return this.isIndirect() ? this._iban.substr(7, 4) : '';
  };
  
  /**
   * Should be called to get client identifier within institution
   * eg. GAVOFYORK
   *
   * @method client
   * @returns {String} client identifier
   */
  Iban.prototype.client = function () {
      return this.isIndirect() ? this._iban.substr(11) : '';
  };
  
  /**
   * Should be called to get client direct address
   *
   * @method address
   * @returns {String} client direct address
   */
  Iban.prototype.address = function () {
      if (this.isDirect()) {
          var base36 = this._iban.substr(4);
          var asBn = new BigNumber(base36, 36);
          return padLeft(asBn.toString(16), 20);
      } 
  
      return '';
  };
  
  Iban.prototype.toString = function () {
      return this._iban;
  };
  
  module.exports = Iban;
  
  
  },{"bignumber.js":"bignumber.js"}],34:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file ipcprovider.js
   * @authors:
   *   Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  "use strict";
  
  var utils = require('../utils/utils');
  var errors = require('./errors');
  
  
  var IpcProvider = function (path, net) {
      var _this = this;
      this.responseCallbacks = {};
      this.path = path;
      
      this.connection = net.connect({path: this.path});
  
      this.connection.on('error', function(e){
          console.error('IPC Connection Error', e);
          _this._timeout();
      });
  
      this.connection.on('end', function(){
          _this._timeout();
      }); 
  
  
      // LISTEN FOR CONNECTION RESPONSES
      this.connection.on('data', function(data) {
          /*jshint maxcomplexity: 6 */
  
          _this._parseResponse(data.toString()).forEach(function(result){
  
              var id = null;
  
              // get the id which matches the returned id
              if(utils.isArray(result)) {
                  result.forEach(function(load){
                      if(_this.responseCallbacks[load.id])
                          id = load.id;
                  });
              } else {
                  id = result.id;
              }
  
              // fire the callback
              if(_this.responseCallbacks[id]) {
                  _this.responseCallbacks[id](null, result);
                  delete _this.responseCallbacks[id];
              }
          });
      });
  };
  
  /**
  Will parse the response and make an array out of it.
  
  @method _parseResponse
  @param {String} data
  */
  IpcProvider.prototype._parseResponse = function(data) {
      var _this = this,
          returnValues = [];
      
      // DE-CHUNKER
      var dechunkedData = data
          .replace(/\}[\n\r]?\{/g,'}|--|{') // }{
          .replace(/\}\][\n\r]?\[\{/g,'}]|--|[{') // }][{
          .replace(/\}[\n\r]?\[\{/g,'}|--|[{') // }[{
          .replace(/\}\][\n\r]?\{/g,'}]|--|{') // }]{
          .split('|--|');
  
      dechunkedData.forEach(function(data){
  
          // prepend the last chunk
          if(_this.lastChunk)
              data = _this.lastChunk + data;
  
          var result = null;
  
          try {
              result = JSON.parse(data);
  
          } catch(e) {
  
              _this.lastChunk = data;
  
              // start timeout to cancel all requests
              clearTimeout(_this.lastChunkTimeout);
              _this.lastChunkTimeout = setTimeout(function(){
                  _this._timeout();
                  throw errors.InvalidResponse(data);
              }, 1000 * 15);
  
              return;
          }
  
          // cancel timeout and set chunk to null
          clearTimeout(_this.lastChunkTimeout);
          _this.lastChunk = null;
  
          if(result)
              returnValues.push(result);
      });
  
      return returnValues;
  };
  
  
  /**
  Get the adds a callback to the responseCallbacks object,
  which will be called if a response matching the response Id will arrive.
  
  @method _addResponseCallback
  */
  IpcProvider.prototype._addResponseCallback = function(payload, callback) {
      var id = payload.id || payload[0].id;
      var method = payload.method || payload[0].method;
  
      this.responseCallbacks[id] = callback;
      this.responseCallbacks[id].method = method;
  };
  
  /**
  Timeout all requests when the end/error event is fired
  
  @method _timeout
  */
  IpcProvider.prototype._timeout = function() {
      for(var key in this.responseCallbacks) {
          if(this.responseCallbacks.hasOwnProperty(key)){
              this.responseCallbacks[key](errors.InvalidConnection('on IPC'));
              delete this.responseCallbacks[key];
          }
      }
  };
  
  
  /**
  Check if the current connection is still valid.
  
  @method isConnected
  */
  IpcProvider.prototype.isConnected = function() {
      var _this = this;
  
      // try reconnect, when connection is gone
      if(!_this.connection.writable)
          _this.connection.connect({path: _this.path});
  
      return !!this.connection.writable;
  };
  
  IpcProvider.prototype.send = function (payload) {
  
      if(this.connection.writeSync) {
          var result;
  
          // try reconnect, when connection is gone
          if(!this.connection.writable)
              this.connection.connect({path: this.path});
  
          var data = this.connection.writeSync(JSON.stringify(payload));
  
          try {
              result = JSON.parse(data);
          } catch(e) {
              throw errors.InvalidResponse(data);                
          }
  
          return result;
  
      } else {
          throw new Error('You tried to send "'+ payload.method +'" synchronously. Synchronous requests are not supported by the IPC provider.');
      }
  };
  
  IpcProvider.prototype.sendAsync = function (payload, callback) {
      // try reconnect, when connection is gone
      if(!this.connection.writable)
          this.connection.connect({path: this.path});
  
  
      this.connection.write(JSON.stringify(payload));
      this._addResponseCallback(payload, callback);
  };
  
  module.exports = IpcProvider;
  
  
  },{"../utils/utils":20,"./errors":26}],35:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file jsonrpc.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   *   Aaron Kumavis <aaron@kumavis.me>
   * @date 2015
   */
  
  // Initialize Jsonrpc as a simple object with utility functions.
  var Jsonrpc = {
      messageId: 0
  };
  
  /**
   * Should be called to valid json create payload object
   *
   * @method toPayload
   * @param {Function} method of jsonrpc call, required
   * @param {Array} params, an array of method params, optional
   * @returns {Object} valid jsonrpc payload object
   */
  Jsonrpc.toPayload = function (method, params) {
      if (!method)
          console.error('jsonrpc method should be specified!');
  
      // advance message ID
      Jsonrpc.messageId++;
  
      return {
          jsonrpc: '2.0',
          id: Jsonrpc.messageId,
          method: method,
          params: params || []
      };
  };
  
  /**
   * Should be called to check if jsonrpc response is valid
   *
   * @method isValidResponse
   * @param {Object}
   * @returns {Boolean} true if response is valid, otherwise false
   */
  Jsonrpc.isValidResponse = function (response) {
      return Array.isArray(response) ? response.every(validateSingleMessage) : validateSingleMessage(response);
  
      function validateSingleMessage(message){
        return !!message &&
          !message.error &&
          message.jsonrpc === '2.0' &&
          typeof message.id === 'number' &&
          message.result !== undefined; // only undefined is not valid json object
      }
  };
  
  /**
   * Should be called to create batch payload object
   *
   * @method toBatchPayload
   * @param {Array} messages, an array of objects with method (required) and params (optional) fields
   * @returns {Array} batch payload
   */
  Jsonrpc.toBatchPayload = function (messages) {
      return messages.map(function (message) {
          return Jsonrpc.toPayload(message.method, message.params);
      });
  };
  
  module.exports = Jsonrpc;
  
  
  },{}],36:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file method.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var utils = require('../utils/utils');
  var errors = require('./errors');
  
  var Method = function (options) {
      this.name = options.name;
      this.call = options.call;
      this.params = options.params || 0;
      this.inputFormatter = options.inputFormatter;
      this.outputFormatter = options.outputFormatter;
      this.requestManager = null;
  };
  
  Method.prototype.setRequestManager = function (rm) {
      this.requestManager = rm;
  };
  
  /**
   * Should be used to determine name of the jsonrpc method based on arguments
   *
   * @method getCall
   * @param {Array} arguments
   * @return {String} name of jsonrpc method
   */
  Method.prototype.getCall = function (args) {
      return utils.isFunction(this.call) ? this.call(args) : this.call;
  };
  
  /**
   * Should be used to extract callback from array of arguments. Modifies input param
   *
   * @method extractCallback
   * @param {Array} arguments
   * @return {Function|Null} callback, if exists
   */
  Method.prototype.extractCallback = function (args) {
      if (utils.isFunction(args[args.length - 1])) {
          return args.pop(); // modify the args array!
      }
  };
  
  /**
   * Should be called to check if the number of arguments is correct
   * 
   * @method validateArgs
   * @param {Array} arguments
   * @throws {Error} if it is not
   */
  Method.prototype.validateArgs = function (args) {
      if (args.length !== this.params) {
          throw errors.InvalidNumberOfRPCParams();
      }
  };
  
  /**
   * Should be called to format input args of method
   * 
   * @method formatInput
   * @param {Array}
   * @return {Array}
   */
  Method.prototype.formatInput = function (args) {
      if (!this.inputFormatter) {
          return args;
      }
  
      return this.inputFormatter.map(function (formatter, index) {
          return formatter ? formatter(args[index]) : args[index];
      });
  };
  
  /**
   * Should be called to format output(result) of method
   *
   * @method formatOutput
   * @param {Object}
   * @return {Object}
   */
  Method.prototype.formatOutput = function (result) {
      return this.outputFormatter && result ? this.outputFormatter(result) : result;
  };
  
  /**
   * Should create payload from given input args
   *
   * @method toPayload
   * @param {Array} args
   * @return {Object}
   */
  Method.prototype.toPayload = function (args) {
      var call = this.getCall(args);
      var callback = this.extractCallback(args);
      var params = this.formatInput(args);
      this.validateArgs(params);
  
      return {
          method: call,
          params: params,
          callback: callback
      };
  };
  
  Method.prototype.attachToObject = function (obj) {
      var func = this.buildCall();
      func.call = this.call; // TODO!!! that's ugly. filter.js uses it
      var name = this.name.split('.');
      if (name.length > 1) {
          obj[name[0]] = obj[name[0]] || {};
          obj[name[0]][name[1]] = func;
      } else {
          obj[name[0]] = func; 
      }
  };
  
  Method.prototype.buildCall = function() {
      var method = this;
      var send = function () {
          var payload = method.toPayload(Array.prototype.slice.call(arguments));
          if (payload.callback) {
              return method.requestManager.sendAsync(payload, function (err, result) {
                  payload.callback(err, method.formatOutput(result));
              });
          }
          return method.formatOutput(method.requestManager.send(payload));
      };
      send.request = this.request.bind(this);
      return send;
  };
  
  /**
   * Should be called to create pure JSONRPC request which can be used in batch request
   *
   * @method request
   * @param {...} params
   * @return {Object} jsonrpc request
   */
  Method.prototype.request = function () {
      var payload = this.toPayload(Array.prototype.slice.call(arguments));
      payload.format = this.formatOutput.bind(this);
      return payload;
  };
  
  module.exports = Method;
  
  },{"../utils/utils":20,"./errors":26}],37:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file bch.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @author Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  "use strict";
  
  var formatters = require('../formatters');
  var Method = require('../method');
  var c = require('../../utils/config');
  var Iban = require('../iban');
  var transfer = require('../transfer');
  
  function Bch(web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  
      this.iban = Iban;
      this.sendIBANTransaction = transfer.bind(null, this);
  }
  
  Object.defineProperty(Bch.prototype, 'defaultAccount', {
      get: function () {
          return c.defaultAccount;
      },
      set: function (val) {
          c.defaultAccount = val;
          return val;
      }
  });
  
  var methods = function () {
      var getBalance = new Method({
          name: 'getBalance',
          call: 'bch_getBalance',
          params: 1,
      });
  
      var getTransaction = new Method({
          name: 'getTransaction',
          call: 'bch_getTransactionByHash',
          params: 1,
          outputFormatter: formatters.outputTransactionFormatter
      });
  
      var sendRawTransaction = new Method({
          name: 'sendRawTransaction',
          call: 'bch_sendRawTransaction',
          params: 1,
          inputFormatter: [null]
      });
  
      var sendTransaction = new Method({
          name: 'sendTransaction',
          call: 'eth_sendTransaction',
          params: 1,
      });
  
      var sign = new Method({
          name: 'sign',
          call: 'eth_sign',
          params: 2,
      });
  
      return [
          getBalance,
          getTransaction,
          sendRawTransaction,
          sendTransaction,
          sign
      ];
  };
  
  module.exports = Bch;
  
  },{"../../utils/config":18,"../formatters":30,"../iban":33,"../method":36,"../transfer":51}],38:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file db.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var Method = require('../method');
  
  var DB = function (web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
      
      methods().forEach(function(method) { 
          method.attachToObject(self);
          method.setRequestManager(web3._requestManager);
      });
  };
  
  var methods = function () {
      var putString = new Method({
          name: 'putString',
          call: 'db_putString',
          params: 3
      });
  
      var getString = new Method({
          name: 'getString',
          call: 'db_getString',
          params: 2
      });
  
      var putHex = new Method({
          name: 'putHex',
          call: 'db_putHex',
          params: 3
      });
  
      var getHex = new Method({
          name: 'getHex',
          call: 'db_getHex',
          params: 2
      });
  
      return [
          putString, getString, putHex, getHex
      ];
  };
  
  module.exports = DB;
  
  },{"../method":36}],39:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file debug.js
   * @author ewasm team
   * @date 2018
   */
  
  "use strict";
  
  var Method = require('../method');
  
  function Debug(web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  }
  
  var methods = function () {
  
      var accountRangeAt = new Method({
          name: 'accountRangeAt',
          call: 'debug_accountRangeAt',
          params: 4
      });
  
      var storageRangeAt = new Method({
          name: 'storageRangeAt',
          call: 'debug_storageRangeAt',
          params: 5
      });
  
      return [
          accountRangeAt,
          storageRangeAt
      ];
  };
  
  module.exports = Debug;
  
  },{"../method":36}],40:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file eth.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @author Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  "use strict";
  
  var formatters = require('../formatters');
  var utils = require('../../utils/utils');
  var Method = require('../method');
  var Property = require('../property');
  var c = require('../../utils/config');
  var Contract = require('../contract');
  var watches = require('./watches');
  var Filter = require('../filter');
  var IsSyncing = require('../syncing');
  var namereg = require('../namereg');
  var Iban = require('../iban');
  var transfer = require('../transfer');
  
  var blockCall = function (args) {
      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? "eth_getBlockByHash" : "eth_getBlockByNumber";
  };
  
  var transactionFromBlockCall = function (args) {
      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getTransactionByBlockHashAndIndex' : 'eth_getTransactionByBlockNumberAndIndex';
  };
  
  var uncleCall = function (args) {
      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleByBlockHashAndIndex' : 'eth_getUncleByBlockNumberAndIndex';
  };
  
  var getBlockTransactionCountCall = function (args) {
      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getBlockTransactionCountByHash' : 'eth_getBlockTransactionCountByNumber';
  };
  
  var uncleCountCall = function (args) {
      return (utils.isString(args[0]) && args[0].indexOf('0x') === 0) ? 'eth_getUncleCountByBlockHash' : 'eth_getUncleCountByBlockNumber';
  };
  
  function Eth(web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  
      properties().forEach(function(p) {
          p.attachToObject(self);
          p.setRequestManager(self._requestManager);
      });
  
  
      this.iban = Iban;
      this.sendIBANTransaction = transfer.bind(null, this);
  }
  
  Object.defineProperty(Eth.prototype, 'defaultBlock', {
      get: function () {
          return c.defaultBlock;
      },
      set: function (val) {
          c.defaultBlock = val;
          return val;
      }
  });
  
  Object.defineProperty(Eth.prototype, 'defaultAccount', {
      get: function () {
          return c.defaultAccount;
      },
      set: function (val) {
          c.defaultAccount = val;
          return val;
      }
  });
  
  var methods = function () {
      var getBalance = new Method({
          name: 'getBalance',
          call: 'eth_getBalance',
          params: 2,
          inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter],
          outputFormatter: formatters.outputBigNumberFormatter
      });
  
      var getStorageAt = new Method({
          name: 'getStorageAt',
          call: 'eth_getStorageAt',
          params: 3,
          inputFormatter: [null, utils.toHex, formatters.inputDefaultBlockNumberFormatter]
      });
  
      var getCode = new Method({
          name: 'getCode',
          call: 'eth_getCode',
          params: 2,
          inputFormatter: [formatters.inputAddressFormatter, formatters.inputDefaultBlockNumberFormatter]
      });
  
      var getBlock = new Method({
          name: 'getBlock',
          call: blockCall,
          params: 2,
          inputFormatter: [formatters.inputBlockNumberFormatter, function (val) { return !!val; }],
          outputFormatter: formatters.outputBlockFormatter
      });
  
      var getUncle = new Method({
          name: 'getUncle',
          call: uncleCall,
          params: 2,
          inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex],
          outputFormatter: formatters.outputBlockFormatter,
  
      });
  
      var getBlockTransactionCount = new Method({
          name: 'getBlockTransactionCount',
          call: getBlockTransactionCountCall,
          params: 1,
          inputFormatter: [formatters.inputBlockNumberFormatter],
          outputFormatter: utils.toDecimal
      });
  
      var getBlockUncleCount = new Method({
          name: 'getBlockUncleCount',
          call: uncleCountCall,
          params: 1,
          inputFormatter: [formatters.inputBlockNumberFormatter],
          outputFormatter: utils.toDecimal
      });
  
      var getTransaction = new Method({
          name: 'getTransaction',
          call: 'eth_getTransactionByHash',
          params: 1,
          outputFormatter: formatters.outputTransactionFormatter
      });
  
      var getTransactionFromBlock = new Method({
          name: 'getTransactionFromBlock',
          call: transactionFromBlockCall,
          params: 2,
          inputFormatter: [formatters.inputBlockNumberFormatter, utils.toHex],
          outputFormatter: formatters.outputTransactionFormatter
      });
  
      var getTransactionReceipt = new Method({
          name: 'getTransactionReceipt',
          call: 'eth_getTransactionReceipt',
          params: 1,
          outputFormatter: formatters.outputTransactionReceiptFormatter
      });
  
      var getTransactionCount = new Method({
          name: 'getTransactionCount',
          call: 'eth_getTransactionCount',
          params: 2,
          inputFormatter: [null, formatters.inputDefaultBlockNumberFormatter],
          outputFormatter: utils.toDecimal
      });
  
      var sendRawTransaction = new Method({
          name: 'sendRawTransaction',
          call: 'eth_sendRawTransaction',
          params: 1,
          inputFormatter: [null]
      });
  
      var sendTransaction = new Method({
          name: 'sendTransaction',
          call: 'eth_sendTransaction',
          params: 1,
          inputFormatter: [formatters.inputTransactionFormatter]
      });
  
      var signTransaction = new Method({
          name: 'signTransaction',
          call: 'eth_signTransaction',
          params: 1,
          inputFormatter: [formatters.inputTransactionFormatter]
      });
  
      var sign = new Method({
          name: 'sign',
          call: 'eth_sign',
          params: 2,
          inputFormatter: [formatters.inputAddressFormatter, null]
      });
  
      var call = new Method({
          name: 'call',
          call: 'eth_call',
          params: 2,
          inputFormatter: [formatters.inputCallFormatter, formatters.inputDefaultBlockNumberFormatter]
      });
  
      var estimateGas = new Method({
          name: 'estimateGas',
          call: 'eth_estimateGas',
          params: 1,
          inputFormatter: [formatters.inputCallFormatter],
          outputFormatter: utils.toDecimal
      });
  
      var getLogs = new Method({
          name: 'getLogs',
          call: 'eth_getLogs',
          params: 1,
          inputFormatter: [formatters.inputGetLogsFormatter],
          outputFormatter: formatters.outputLogFormatter
      });
  
      var submitWork = new Method({
          name: 'submitWork',
          call: 'eth_submitWork',
          params: 3
      });
  
      var getWork = new Method({
          name: 'getWork',
          call: 'eth_getWork',
          params: 0
      });
  
      return [
          getBalance,
          getStorageAt,
          getCode,
          getBlock,
          getUncle,
          getBlockTransactionCount,
          getBlockUncleCount,
          getTransaction,
          getTransactionFromBlock,
          getTransactionReceipt,
          getTransactionCount,
          call,
          estimateGas,
          sendRawTransaction,
          signTransaction,
          sendTransaction,
          sign,
          submitWork,
          getLogs,
          getWork
      ];
  };
  
  
  var properties = function () {
      return [
          new Property({
              name: 'coinbase',
              getter: 'eth_coinbase'
          }),
          new Property({
              name: 'mining',
              getter: 'eth_mining'
          }),
          new Property({
              name: 'hashrate',
              getter: 'eth_hashrate',
              outputFormatter: utils.toDecimal
          }),
          new Property({
              name: 'syncing',
              getter: 'eth_syncing',
              outputFormatter: formatters.outputSyncingFormatter
          }),
          new Property({
              name: 'gasPrice',
              getter: 'eth_gasPrice',
              outputFormatter: formatters.outputBigNumberFormatter
          }),
          new Property({
              name: 'accounts',
              getter: 'eth_accounts'
          }),
          new Property({
              name: 'blockNumber',
              getter: 'eth_blockNumber',
              outputFormatter: utils.toDecimal
          }),
          new Property({
              name: 'protocolVersion',
              getter: 'eth_protocolVersion'
          })
      ];
  };
  
  Eth.prototype.contract = function (abi) {
      var factory = new Contract(this, abi);
      return factory;
  };
  
  Eth.prototype.filter = function (options, callback, filterCreationErrorCallback) {
      return new Filter(options, 'eth', this._requestManager, watches.eth(), formatters.outputLogFormatter, callback, filterCreationErrorCallback);
  };
  
  Eth.prototype.namereg = function () {
      return this.contract(namereg.global.abi).at(namereg.global.address);
  };
  
  Eth.prototype.icapNamereg = function () {
      return this.contract(namereg.icap.abi).at(namereg.icap.address);
  };
  
  Eth.prototype.isSyncing = function (callback) {
      return new IsSyncing(this._requestManager, callback);
  };
  
  module.exports = Eth;
  
  },{"../../utils/config":18,"../../utils/utils":20,"../contract":25,"../filter":29,"../formatters":30,"../iban":33,"../method":36,"../namereg":46,"../property":47,"../syncing":50,"../transfer":51,"./watches":45}],41:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file eth.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var utils = require('../../utils/utils');
  var Property = require('../property');
  
  var Net = function (web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      properties().forEach(function(p) { 
          p.attachToObject(self);
          p.setRequestManager(web3._requestManager);
      });
  };
  
  /// @returns an array of objects describing web3.eth api properties
  var properties = function () {
      return [
          new Property({
              name: 'listening',
              getter: 'net_listening'
          }),
          new Property({
              name: 'peerCount',
              getter: 'net_peerCount',
              outputFormatter: utils.toDecimal
          })
      ];
  };
  
  module.exports = Net;
  
  },{"../../utils/utils":20,"../property":47}],42:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file eth.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @author Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  "use strict";
  
  var Method = require('../method');
  var Property = require('../property');
  var formatters = require('../formatters');
  
  function Personal(web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  
      properties().forEach(function(p) {
          p.attachToObject(self);
          p.setRequestManager(self._requestManager);
      });
  }
  
  var methods = function () {
      var newAccount = new Method({
          name: 'newAccount',
          call: 'personal_newAccount',
          params: 1,
          inputFormatter: [null]
      });
  
      var importRawKey = new Method({
          name: 'importRawKey',
  		call: 'personal_importRawKey',
  		params: 2
      });
  
      var sign = new Method({
          name: 'sign',
  		call: 'personal_sign',
  		params: 3,
  		inputFormatter: [null, formatters.inputAddressFormatter, null]
      });
  
      var ecRecover = new Method({
          name: 'ecRecover',
  		call: 'personal_ecRecover',
  		params: 2
      });
  
      var unlockAccount = new Method({
          name: 'unlockAccount',
          call: 'personal_unlockAccount',
          params: 3,
          inputFormatter: [formatters.inputAddressFormatter, null, null]
      });
  
      var sendTransaction = new Method({
          name: 'sendTransaction',
          call: 'personal_sendTransaction',
          params: 2,
          inputFormatter: [formatters.inputTransactionFormatter, null]
      });
  
      var lockAccount = new Method({
          name: 'lockAccount',
          call: 'personal_lockAccount',
          params: 1,
          inputFormatter: [formatters.inputAddressFormatter]
      });
  
      return [
          newAccount,
          importRawKey,
          unlockAccount,
          ecRecover,
          sign,
          sendTransaction,
          lockAccount
      ];
  };
  
  var properties = function () {
      return [
          new Property({
              name: 'listAccounts',
              getter: 'personal_listAccounts'
          })
      ];
  };
  
  
  module.exports = Personal;
  
  },{"../formatters":30,"../method":36,"../property":47}],43:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file shh.js
   * @authors:
   *   Fabian Vogelsteller <fabian@ethereum.org>
   *   Marek Kotewicz <marek@ethcore.io>
   * @date 2017
   */
  
  var Method = require('../method');
  var Filter = require('../filter');
  var watches = require('./watches');
  
  var Shh = function (web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  };
  
  Shh.prototype.newMessageFilter = function (options, callback, filterCreationErrorCallback) {
      return new Filter(options, 'shh', this._requestManager, watches.shh(), null, callback, filterCreationErrorCallback);
  };
  
  var methods = function () {
  
      return [
          new Method({
              name: 'version',
              call: 'shh_version',
              params: 0
          }),
          new Method({
              name: 'info',
              call: 'shh_info',
              params: 0
          }),
          new Method({
              name: 'setMaxMessageSize',
              call: 'shh_setMaxMessageSize',
              params: 1
          }),
          new Method({
              name: 'setMinPoW',
              call: 'shh_setMinPoW',
              params: 1
          }),
          new Method({
              name: 'markTrustedPeer',
              call: 'shh_markTrustedPeer',
              params: 1
          }),
          new Method({
              name: 'newKeyPair',
              call: 'shh_newKeyPair',
              params: 0
          }),
          new Method({
              name: 'addPrivateKey',
              call: 'shh_addPrivateKey',
              params: 1
          }),
          new Method({
              name: 'deleteKeyPair',
              call: 'shh_deleteKeyPair',
              params: 1
          }),
          new Method({
              name: 'hasKeyPair',
              call: 'shh_hasKeyPair',
              params: 1
          }),
          new Method({
              name: 'getPublicKey',
              call: 'shh_getPublicKey',
              params: 1
          }),
          new Method({
              name: 'getPrivateKey',
              call: 'shh_getPrivateKey',
              params: 1
          }),
          new Method({
              name: 'newSymKey',
              call: 'shh_newSymKey',
              params: 0
          }),
          new Method({
              name: 'addSymKey',
              call: 'shh_addSymKey',
              params: 1
          }),
          new Method({
              name: 'generateSymKeyFromPassword',
              call: 'shh_generateSymKeyFromPassword',
              params: 1
          }),
          new Method({
              name: 'hasSymKey',
              call: 'shh_hasSymKey',
              params: 1
          }),
          new Method({
              name: 'getSymKey',
              call: 'shh_getSymKey',
              params: 1
          }),
          new Method({
              name: 'deleteSymKey',
              call: 'shh_deleteSymKey',
              params: 1
          }),
  
          // subscribe and unsubscribe missing
  
          new Method({
              name: 'post',
              call: 'shh_post',
              params: 1,
              inputFormatter: [null]
          })
      ];
  };
  
  module.exports = Shh;
  
  
  },{"../filter":29,"../method":36,"./watches":45}],44:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file bzz.js
   * @author Alex Beregszaszi <alex@rtfs.hu>
   * @date 2016
   *
   * Reference: https://github.com/ethereum/go-ethereum/blob/swarm/internal/web3ext/web3ext.go#L33
   */
  
  "use strict";
  
  var Method = require('../method');
  var Property = require('../property');
  
  function Swarm(web3) {
      this._requestManager = web3._requestManager;
  
      var self = this;
  
      methods().forEach(function(method) {
          method.attachToObject(self);
          method.setRequestManager(self._requestManager);
      });
  
      properties().forEach(function(p) {
          p.attachToObject(self);
          p.setRequestManager(self._requestManager);
      });
  }
  
  var methods = function () {
      var blockNetworkRead = new Method({
          name: 'blockNetworkRead',
          call: 'bzz_blockNetworkRead',
          params: 1,
          inputFormatter: [null]
      });
  
      var syncEnabled = new Method({
          name: 'syncEnabled',
          call: 'bzz_syncEnabled',
          params: 1,
          inputFormatter: [null]
      });
  
      var swapEnabled = new Method({
          name: 'swapEnabled',
          call: 'bzz_swapEnabled',
          params: 1,
          inputFormatter: [null]
      });
  
      var download = new Method({
          name: 'download',
          call: 'bzz_download',
          params: 2,
          inputFormatter: [null, null]
      });
  
      var upload = new Method({
          name: 'upload',
          call: 'bzz_upload',
          params: 2,
          inputFormatter: [null, null]
      });
  
      var retrieve = new Method({
          name: 'retrieve',
          call: 'bzz_retrieve',
          params: 1,
          inputFormatter: [null]
      });
  
      var store = new Method({
          name: 'store',
          call: 'bzz_store',
          params: 2,
          inputFormatter: [null, null]
      });
  
      var get = new Method({
          name: 'get',
          call: 'bzz_get',
          params: 1,
          inputFormatter: [null]
      });
  
      var put = new Method({
          name: 'put',
          call: 'bzz_put',
          params: 2,
          inputFormatter: [null, null]
      });
  
      var modify = new Method({
          name: 'modify',
          call: 'bzz_modify',
          params: 4,
          inputFormatter: [null, null, null, null]
      });
  
      return [
          blockNetworkRead,
          syncEnabled,
          swapEnabled,
          download,
          upload,
          retrieve,
          store,
          get,
          put,
          modify
      ];
  };
  
  var properties = function () {
      return [
          new Property({
              name: 'hive',
              getter: 'bzz_hive'
          }),
          new Property({
              name: 'info',
              getter: 'bzz_info'
          })
      ];
  };
  
  
  module.exports = Swarm;
  
  },{"../method":36,"../property":47}],45:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file watches.js
   * @authors:
   *   Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var Method = require('../method');
  
  /// @returns an array of objects describing web3.eth.filter api methods
  var eth = function () {
      var newFilterCall = function (args) {
          var type = args[0];
  
          switch(type) {
              case 'latest':
                  args.shift();
                  this.params = 0;
                  return 'eth_newBlockFilter';
              case 'pending':
                  args.shift();
                  this.params = 0;
                  return 'eth_newPendingTransactionFilter';
              default:
                  return 'eth_newFilter';
          }
      };
  
      var newFilter = new Method({
          name: 'newFilter',
          call: newFilterCall,
          params: 1
      });
  
      var uninstallFilter = new Method({
          name: 'uninstallFilter',
          call: 'eth_uninstallFilter',
          params: 1
      });
  
      var getLogs = new Method({
          name: 'getLogs',
          call: 'eth_getFilterLogs',
          params: 1
      });
  
      var poll = new Method({
          name: 'poll',
          call: 'eth_getFilterChanges',
          params: 1
      });
  
      return [
          newFilter,
          uninstallFilter,
          getLogs,
          poll
      ];
  };
  
  /// @returns an array of objects describing web3.shh.watch api methods
  var shh = function () {
  
      return [
          new Method({
              name: 'newFilter',
              call: 'shh_newMessageFilter',
              params: 1
          }),
          new Method({
              name: 'uninstallFilter',
              call: 'shh_deleteMessageFilter',
              params: 1
          }),
          new Method({
              name: 'getLogs',
              call: 'shh_getFilterMessages',
              params: 1
          }),
          new Method({
              name: 'poll',
              call: 'shh_getFilterMessages',
              params: 1
          })
      ];
  };
  
  module.exports = {
      eth: eth,
      shh: shh
  };
  
  
  },{"../method":36}],46:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file namereg.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var globalRegistrarAbi = require('../contracts/GlobalRegistrar.json');
  var icapRegistrarAbi= require('../contracts/ICAPRegistrar.json');
  
  var globalNameregAddress = '0xc6d9d2cd449a754c494264e1809c50e34d64562b';
  var icapNameregAddress = '0xa1a111bc074c9cfa781f0c38e63bd51c91b8af00';
  
  module.exports = {
      global: {
          abi: globalRegistrarAbi,
          address: globalNameregAddress
      },
      icap: {
          abi: icapRegistrarAbi,
          address: icapNameregAddress
      }
  };
  
  
  },{"../contracts/GlobalRegistrar.json":1,"../contracts/ICAPRegistrar.json":2}],47:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /**
   * @file property.js
   * @author Fabian Vogelsteller <fabian@frozeman.de>
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var utils = require('../utils/utils');
  
  var Property = function (options) {
      this.name = options.name;
      this.getter = options.getter;
      this.setter = options.setter;
      this.outputFormatter = options.outputFormatter;
      this.inputFormatter = options.inputFormatter;
      this.requestManager = null;
  };
  
  Property.prototype.setRequestManager = function (rm) {
      this.requestManager = rm;
  };
  
  /**
   * Should be called to format input args of method
   *
   * @method formatInput
   * @param {Array}
   * @return {Array}
   */
  Property.prototype.formatInput = function (arg) {
      return this.inputFormatter ? this.inputFormatter(arg) : arg;
  };
  
  /**
   * Should be called to format output(result) of method
   *
   * @method formatOutput
   * @param {Object}
   * @return {Object}
   */
  Property.prototype.formatOutput = function (result) {
      return this.outputFormatter && result !== null && result !== undefined ? this.outputFormatter(result) : result;
  };
  
  /**
   * Should be used to extract callback from array of arguments. Modifies input param
   *
   * @method extractCallback
   * @param {Array} arguments
   * @return {Function|Null} callback, if exists
   */
  Property.prototype.extractCallback = function (args) {
      if (utils.isFunction(args[args.length - 1])) {
          return args.pop(); // modify the args array!
      }
  };
  
  
  /**
   * Should attach function to method
   *
   * @method attachToObject
   * @param {Object}
   * @param {Function}
   */
  Property.prototype.attachToObject = function (obj) {
      var proto = {
          get: this.buildGet(),
          enumerable: true
      };
  
      var names = this.name.split('.');
      var name = names[0];
      if (names.length > 1) {
          obj[names[0]] = obj[names[0]] || {};
          obj = obj[names[0]];
          name = names[1];
      }
  
      Object.defineProperty(obj, name, proto);
      obj[asyncGetterName(name)] = this.buildAsyncGet();
  };
  
  var asyncGetterName = function (name) {
      return 'get' + name.charAt(0).toUpperCase() + name.slice(1);
  };
  
  Property.prototype.buildGet = function () {
      var property = this;
      return function get() {
          return property.formatOutput(property.requestManager.send({
              method: property.getter
          }));
      };
  };
  
  Property.prototype.buildAsyncGet = function () {
      var property = this;
      var get = function (callback) {
          property.requestManager.sendAsync({
              method: property.getter
          }, function (err, result) {
              callback(err, property.formatOutput(result));
          });
      };
      get.request = this.request.bind(this);
      return get;
  };
  
  /**
   * Should be called to create pure JSONRPC request which can be used in batch request
   *
   * @method request
   * @param {...} params
   * @return {Object} jsonrpc request
   */
  Property.prototype.request = function () {
      var payload = {
          method: this.getter,
          params: [],
          callback: this.extractCallback(Array.prototype.slice.call(arguments))
      };
      payload.format = this.formatOutput.bind(this);
      return payload;
  };
  
  module.exports = Property;
  
  
  },{"../utils/utils":20}],48:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file requestmanager.js
   * @author Jeffrey Wilcke <jeff@ethdev.com>
   * @author Marek Kotewicz <marek@ethdev.com>
   * @author Marian Oancea <marian@ethdev.com>
   * @author Fabian Vogelsteller <fabian@ethdev.com>
   * @author Gav Wood <g@ethdev.com>
   * @date 2014
   */
  
  var Jsonrpc = require('./jsonrpc');
  var utils = require('../utils/utils');
  var c = require('../utils/config');
  var errors = require('./errors');
  
  /**
   * It's responsible for passing messages to providers
   * It's also responsible for polling the ethereum node for incoming messages
   * Default poll timeout is 1 second
   * Singleton
   */
  var RequestManager = function (provider) {
      this.provider = provider;
      this.polls = {};
      this.timeout = null;
  };
  
  /**
   * Should be used to synchronously send request
   *
   * @method send
   * @param {Object} data
   * @return {Object}
   */
  RequestManager.prototype.send = function (data) {
      if (!this.provider) {
          console.error(errors.InvalidProvider());
          return null;
      }
  
      var payload = Jsonrpc.toPayload(data.method, data.params);
      var result = this.provider.send(payload);
  
      if (!Jsonrpc.isValidResponse(result)) {
          throw errors.InvalidResponse(result);
      }
  
      return result.result;
  };
  
  /**
   * Should be used to asynchronously send request
   *
   * @method sendAsync
   * @param {Object} data
   * @param {Function} callback
   */
  RequestManager.prototype.sendAsync = function (data, callback) {
      if (!this.provider) {
          return callback(errors.InvalidProvider());
      }
  
      var payload = Jsonrpc.toPayload(data.method, data.params);
      this.provider.sendAsync(payload, function (err, result) {
          if (err) {
              return callback(err);
          }
          
          if (!Jsonrpc.isValidResponse(result)) {
              return callback(errors.InvalidResponse(result));
          }
  
          callback(null, result.result);
      });
  };
  
  /**
   * Should be called to asynchronously send batch request
   *
   * @method sendBatch
   * @param {Array} batch data
   * @param {Function} callback
   */
  RequestManager.prototype.sendBatch = function (data, callback) {
      if (!this.provider) {
          return callback(errors.InvalidProvider());
      }
  
      var payload = Jsonrpc.toBatchPayload(data);
  
      this.provider.sendAsync(payload, function (err, results) {
          if (err) {
              return callback(err);
          }
  
          if (!utils.isArray(results)) {
              return callback(errors.InvalidResponse(results));
          }
  
          callback(err, results);
      }); 
  };
  
  /**
   * Should be used to set provider of request manager
   *
   * @method setProvider
   * @param {Object}
   */
  RequestManager.prototype.setProvider = function (p) {
      this.provider = p;
  };
  
  /**
   * Should be used to start polling
   *
   * @method startPolling
   * @param {Object} data
   * @param {Number} pollId
   * @param {Function} callback
   * @param {Function} uninstall
   *
   * @todo cleanup number of params
   */
  RequestManager.prototype.startPolling = function (data, pollId, callback, uninstall) {
      this.polls[pollId] = {data: data, id: pollId, callback: callback, uninstall: uninstall};
  
  
      // start polling
      if (!this.timeout) {
          this.poll();
      }
  };
  
  /**
   * Should be used to stop polling for filter with given id
   *
   * @method stopPolling
   * @param {Number} pollId
   */
  RequestManager.prototype.stopPolling = function (pollId) {
      delete this.polls[pollId];
  
      // stop polling
      if(Object.keys(this.polls).length === 0 && this.timeout) {
          clearTimeout(this.timeout);
          this.timeout = null;
      }
  };
  
  /**
   * Should be called to reset the polling mechanism of the request manager
   *
   * @method reset
   */
  RequestManager.prototype.reset = function (keepIsSyncing) {
      /*jshint maxcomplexity:5 */
  
      for (var key in this.polls) {
          // remove all polls, except sync polls,
          // they need to be removed manually by calling syncing.stopWatching()
          if(!keepIsSyncing || key.indexOf('syncPoll_') === -1) {
              this.polls[key].uninstall();
              delete this.polls[key];
          }
      }
  
      // stop polling
      if(Object.keys(this.polls).length === 0 && this.timeout) {
          clearTimeout(this.timeout);
          this.timeout = null;
      }
  };
  
  /**
   * Should be called to poll for changes on filter with given id
   *
   * @method poll
   */
  RequestManager.prototype.poll = function () {
      /*jshint maxcomplexity: 6 */
      this.timeout = setTimeout(this.poll.bind(this), c.ETH_POLLING_TIMEOUT);
  
      if (Object.keys(this.polls).length === 0) {
          return;
      }
  
      if (!this.provider) {
          console.error(errors.InvalidProvider());
          return;
      }
  
      var pollsData = [];
      var pollsIds = [];
      for (var key in this.polls) {
          pollsData.push(this.polls[key].data);
          pollsIds.push(key);
      }
  
      if (pollsData.length === 0) {
          return;
      }
  
      var payload = Jsonrpc.toBatchPayload(pollsData);
      
      // map the request id to they poll id
      var pollsIdMap = {};
      payload.forEach(function(load, index){
          pollsIdMap[load.id] = pollsIds[index];
      });
  
  
      var self = this;
      this.provider.sendAsync(payload, function (error, results) {
  
  
          // TODO: console log?
          if (error) {
              return;
          }
  
          if (!utils.isArray(results)) {
              throw errors.InvalidResponse(results);
          }
          results.map(function (result) {
              var id = pollsIdMap[result.id];
  
              // make sure the filter is still installed after arrival of the request
              if (self.polls[id]) {
                  result.callback = self.polls[id].callback;
                  return result;
              } else
                  return false;
          }).filter(function (result) {
              return !!result; 
          }).filter(function (result) {
              var valid = Jsonrpc.isValidResponse(result);
              if (!valid) {
                  result.callback(errors.InvalidResponse(result));
              }
              return valid;
          }).forEach(function (result) {
              result.callback(null, result.result);
          });
      });
  };
  
  module.exports = RequestManager;
  
  
  },{"../utils/config":18,"../utils/utils":20,"./errors":26,"./jsonrpc":35}],49:[function(require,module,exports){
  
  
  var Settings = function () {
      this.defaultBlock = 'latest';
      this.defaultAccount = undefined;
  };
  
  module.exports = Settings;
  
  
  },{}],50:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** @file syncing.js
   * @authors:
   *   Fabian Vogelsteller <fabian@ethdev.com>
   * @date 2015
   */
  
  var formatters = require('./formatters');
  var utils = require('../utils/utils');
  
  var count = 1;
  
  /**
  Adds the callback and sets up the methods, to iterate over the results.
  
  @method pollSyncing
  @param {Object} self
  */
  var pollSyncing = function(self) {
  
      var onMessage = function (error, sync) {
          if (error) {
              return self.callbacks.forEach(function (callback) {
                  callback(error);
              });
          }
  
          if(utils.isObject(sync) && sync.startingBlock)
              sync = formatters.outputSyncingFormatter(sync);
  
          self.callbacks.forEach(function (callback) {
              if (self.lastSyncState !== sync) {
                  
                  // call the callback with true first so the app can stop anything, before receiving the sync data
                  if(!self.lastSyncState && utils.isObject(sync))
                      callback(null, true);
                  
                  // call on the next CPU cycle, so the actions of the sync stop can be processes first
                  setTimeout(function() {
                      callback(null, sync);
                  }, 0);
                  
                  self.lastSyncState = sync;
              }
          });
      };
  
      self.requestManager.startPolling({
          method: 'eth_syncing',
          params: [],
      }, self.pollId, onMessage, self.stopWatching.bind(self));
  
  };
  
  var IsSyncing = function (requestManager, callback) {
      this.requestManager = requestManager;
      this.pollId = 'syncPoll_'+ count++;
      this.callbacks = [];
      this.addCallback(callback);
      this.lastSyncState = false;
      pollSyncing(this);
  
      return this;
  };
  
  IsSyncing.prototype.addCallback = function (callback) {
      if(callback)
          this.callbacks.push(callback);
      return this;
  };
  
  IsSyncing.prototype.stopWatching = function () {
      this.requestManager.stopPolling(this.pollId);
      this.callbacks = [];
  };
  
  module.exports = IsSyncing;
  
  
  },{"../utils/utils":20,"./formatters":30}],51:[function(require,module,exports){
  /*
      This file is part of web3.js.
  
      web3.js is free software: you can redistribute it and/or modify
      it under the terms of the GNU Lesser General Public License as published by
      the Free Software Foundation, either version 3 of the License, or
      (at your option) any later version.
  
      web3.js is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU Lesser General Public License for more details.
  
      You should have received a copy of the GNU Lesser General Public License
      along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  */
  /** 
   * @file transfer.js
   * @author Marek Kotewicz <marek@ethdev.com>
   * @date 2015
   */
  
  var Iban = require('./iban');
  var exchangeAbi = require('../contracts/SmartExchange.json');
  
  /**
   * Should be used to make Iban transfer
   *
   * @method transfer
   * @param {String} from
   * @param {String} to iban
   * @param {Value} value to be tranfered
   * @param {Function} callback, callback
   */
  var transfer = function (eth, from, to, value, callback) {
      var iban = new Iban(to); 
      if (!iban.isValid()) {
          throw new Error('invalid iban address');
      }
  
      if (iban.isDirect()) {
          return transferToAddress(eth, from, iban.address(), value, callback);
      }
      
      if (!callback) {
          var address = eth.icapNamereg().addr(iban.institution());
          return deposit(eth, from, address, value, iban.client());
      }
  
      eth.icapNamereg().addr(iban.institution(), function (err, address) {
          return deposit(eth, from, address, value, iban.client(), callback);
      });
      
  };
  
  /**
   * Should be used to transfer funds to certain address
   *
   * @method transferToAddress
   * @param {String} from
   * @param {String} to
   * @param {Value} value to be tranfered
   * @param {Function} callback, callback
   */
  var transferToAddress = function (eth, from, to, value, callback) {
      return eth.sendTransaction({
          address: to,
          from: from,
          value: value
      }, callback);
  };
  
  /**
   * Should be used to deposit funds to generic Exchange contract (must implement deposit(bytes32) method!)
   *
   * @method deposit
   * @param {String} from
   * @param {String} to
   * @param {Value} value to be transfered
   * @param {String} client unique identifier
   * @param {Function} callback, callback
   */
  var deposit = function (eth, from, to, value, client, callback) {
      var abi = exchangeAbi;
      return eth.contract(abi).at(to).deposit(client, {
          from: from,
          value: value
      }, callback);
  };
  
  module.exports = transfer;
  
  
  },{"../contracts/SmartExchange.json":3,"./iban":33}],52:[function(require,module,exports){
  'use strict'
  
  exports.byteLength = byteLength
  exports.toByteArray = toByteArray
  exports.fromByteArray = fromByteArray
  
  var lookup = []
  var revLookup = []
  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
  
  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  for (var i = 0, len = code.length; i < len; ++i) {
    lookup[i] = code[i]
    revLookup[code.charCodeAt(i)] = i
  }
  
  // Support decoding URL-safe base64 strings, as Node.js does.
  // See: https://en.wikipedia.org/wiki/Base64#URL_applications
  revLookup['-'.charCodeAt(0)] = 62
  revLookup['_'.charCodeAt(0)] = 63
  
  function getLens (b64) {
    var len = b64.length
  
    if (len % 4 > 0) {
      throw new Error('Invalid string. Length must be a multiple of 4')
    }
  
    // Trim off extra bytes after placeholder bytes are found
    // See: https://github.com/beatgammit/base64-js/issues/42
    var validLen = b64.indexOf('=')
    if (validLen === -1) validLen = len
  
    var placeHoldersLen = validLen === len
      ? 0
      : 4 - (validLen % 4)
  
    return [validLen, placeHoldersLen]
  }
  
  // base64 is 4/3 + up to two characters of the original data
  function byteLength (b64) {
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function _byteLength (b64, validLen, placeHoldersLen) {
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function toByteArray (b64) {
    var tmp
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
  
    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
  
    var curByte = 0
  
    // if there are placeholders, only get up to the last complete 4 chars
    var len = placeHoldersLen > 0
      ? validLen - 4
      : validLen
  
    for (var i = 0; i < len; i += 4) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 18) |
        (revLookup[b64.charCodeAt(i + 1)] << 12) |
        (revLookup[b64.charCodeAt(i + 2)] << 6) |
        revLookup[b64.charCodeAt(i + 3)]
      arr[curByte++] = (tmp >> 16) & 0xFF
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 2) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 2) |
        (revLookup[b64.charCodeAt(i + 1)] >> 4)
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 1) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 10) |
        (revLookup[b64.charCodeAt(i + 1)] << 4) |
        (revLookup[b64.charCodeAt(i + 2)] >> 2)
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    return arr
  }
  
  function tripletToBase64 (num) {
    return lookup[num >> 18 & 0x3F] +
      lookup[num >> 12 & 0x3F] +
      lookup[num >> 6 & 0x3F] +
      lookup[num & 0x3F]
  }
  
  function encodeChunk (uint8, start, end) {
    var tmp
    var output = []
    for (var i = start; i < end; i += 3) {
      tmp =
        ((uint8[i] << 16) & 0xFF0000) +
        ((uint8[i + 1] << 8) & 0xFF00) +
        (uint8[i + 2] & 0xFF)
      output.push(tripletToBase64(tmp))
    }
    return output.join('')
  }
  
  function fromByteArray (uint8) {
    var tmp
    var len = uint8.length
    var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
    var parts = []
    var maxChunkLength = 16383 // must be multiple of 3
  
    // go through the array every three bytes, we'll deal with trailing stuff later
    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
      parts.push(encodeChunk(
        uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
      ))
    }
  
    // pad the end with zeros, but make sure to not forget the extra bytes
    if (extraBytes === 1) {
      tmp = uint8[len - 1]
      parts.push(
        lookup[tmp >> 2] +
        lookup[(tmp << 4) & 0x3F] +
        '=='
      )
    } else if (extraBytes === 2) {
      tmp = (uint8[len - 2] << 8) + uint8[len - 1]
      parts.push(
        lookup[tmp >> 10] +
        lookup[(tmp >> 4) & 0x3F] +
        lookup[(tmp << 2) & 0x3F] +
        '='
      )
    }
  
    return parts.join('')
  }
  
  },{}],53:[function(require,module,exports){
  
  },{}],54:[function(require,module,exports){
  arguments[4][53][0].apply(exports,arguments)
  },{"dup":53}],55:[function(require,module,exports){
  /*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <https://feross.org>
   * @license  MIT
   */
  /* eslint-disable no-proto */
  
  'use strict'
  
  var base64 = require('base64-js')
  var ieee754 = require('ieee754')
  
  exports.Buffer = Buffer
  exports.SlowBuffer = SlowBuffer
  exports.INSPECT_MAX_BYTES = 50
  
  var K_MAX_LENGTH = 0x7fffffff
  exports.kMaxLength = K_MAX_LENGTH
  
  /**
   * If `Buffer.TYPED_ARRAY_SUPPORT`:
   *   === true    Use Uint8Array implementation (fastest)
   *   === false   Print warning and recommend using `buffer` v4.x which has an 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+.
   *
   * We report that the browser does not support typed arrays if the are not subclassable
   * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
   * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
   * for __proto__ and has a buggy typed array implementation.
   */
  Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
  
  if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
      typeof console.error === 'function') {
    console.error(
      'This browser lacks typed array (Uint8Array) support which is required by ' +
      '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
    )
  }
  
  function typedArraySupport () {
    // Can typed array instances can be augmented?
    try {
      var arr = new Uint8Array(1)
      arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
      return arr.foo() === 42
    } catch (e) {
      return false
    }
  }
  
  Object.defineProperty(Buffer.prototype, 'parent', {
    enumerable: true,
    get: function () {
      if (!Buffer.isBuffer(this)) return undefined
      return this.buffer
    }
  })
  
  Object.defineProperty(Buffer.prototype, 'offset', {
    enumerable: true,
    get: function () {
      if (!Buffer.isBuffer(this)) return undefined
      return this.byteOffset
    }
  })
  
  function createBuffer (length) {
    if (length > K_MAX_LENGTH) {
      throw new RangeError('The value "' + length + '" is invalid for option "size"')
    }
    // Return an augmented `Uint8Array` instance
    var buf = new Uint8Array(length)
    buf.__proto__ = Buffer.prototype
    return buf
  }
  
  /**
   * The Buffer constructor returns instances of `Uint8Array` that have their
   * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
   * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
   * and the `Uint8Array` methods. Square bracket notation works as expected -- it
   * returns a single octet.
   *
   * The `Uint8Array` prototype remains unmodified.
   */
  
  function Buffer (arg, encodingOrOffset, length) {
    // Common case.
    if (typeof arg === 'number') {
      if (typeof encodingOrOffset === 'string') {
        throw new TypeError(
          'The "string" argument must be of type string. Received type number'
        )
      }
      return allocUnsafe(arg)
    }
    return from(arg, encodingOrOffset, length)
  }
  
  // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
  if (typeof Symbol !== 'undefined' && Symbol.species != null &&
      Buffer[Symbol.species] === Buffer) {
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true,
      enumerable: false,
      writable: false
    })
  }
  
  Buffer.poolSize = 8192 // not used by this implementation
  
  function from (value, encodingOrOffset, length) {
    if (typeof value === 'string') {
      return fromString(value, encodingOrOffset)
    }
  
    if (ArrayBuffer.isView(value)) {
      return fromArrayLike(value)
    }
  
    if (value == null) {
      throw TypeError(
        'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
        'or Array-like Object. Received type ' + (typeof value)
      )
    }
  
    if (isInstance(value, ArrayBuffer) ||
        (value && isInstance(value.buffer, ArrayBuffer))) {
      return fromArrayBuffer(value, encodingOrOffset, length)
    }
  
    if (typeof value === 'number') {
      throw new TypeError(
        'The "value" argument must not be of type number. Received type number'
      )
    }
  
    var valueOf = value.valueOf && value.valueOf()
    if (valueOf != null && valueOf !== value) {
      return Buffer.from(valueOf, encodingOrOffset, length)
    }
  
    var b = fromObject(value)
    if (b) return b
  
    if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
        typeof value[Symbol.toPrimitive] === 'function') {
      return Buffer.from(
        value[Symbol.toPrimitive]('string'), encodingOrOffset, length
      )
    }
  
    throw new TypeError(
      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
      'or Array-like Object. Received type ' + (typeof value)
    )
  }
  
  /**
   * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
   * if value is a number.
   * Buffer.from(str[, encoding])
   * Buffer.from(array)
   * Buffer.from(buffer)
   * Buffer.from(arrayBuffer[, byteOffset[, length]])
   **/
  Buffer.from = function (value, encodingOrOffset, length) {
    return from(value, encodingOrOffset, length)
  }
  
  // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
  // https://github.com/feross/buffer/pull/148
  Buffer.prototype.__proto__ = Uint8Array.prototype
  Buffer.__proto__ = Uint8Array
  
  function assertSize (size) {
    if (typeof size !== 'number') {
      throw new TypeError('"size" argument must be of type number')
    } else if (size < 0) {
      throw new RangeError('The value "' + size + '" is invalid for option "size"')
    }
  }
  
  function alloc (size, fill, encoding) {
    assertSize(size)
    if (size <= 0) {
      return createBuffer(size)
    }
    if (fill !== undefined) {
      // Only pay attention to encoding if it's a string. This
      // prevents accidentally sending in a number that would
      // be interpretted as a start offset.
      return typeof encoding === 'string'
        ? createBuffer(size).fill(fill, encoding)
        : createBuffer(size).fill(fill)
    }
    return createBuffer(size)
  }
  
  /**
   * Creates a new filled Buffer instance.
   * alloc(size[, fill[, encoding]])
   **/
  Buffer.alloc = function (size, fill, encoding) {
    return alloc(size, fill, encoding)
  }
  
  function allocUnsafe (size) {
    assertSize(size)
    return createBuffer(size < 0 ? 0 : checked(size) | 0)
  }
  
  /**
   * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
   * */
  Buffer.allocUnsafe = function (size) {
    return allocUnsafe(size)
  }
  /**
   * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
   */
  Buffer.allocUnsafeSlow = function (size) {
    return allocUnsafe(size)
  }
  
  function fromString (string, encoding) {
    if (typeof encoding !== 'string' || encoding === '') {
      encoding = 'utf8'
    }
  
    if (!Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  
    var length = byteLength(string, encoding) | 0
    var buf = createBuffer(length)
  
    var actual = buf.write(string, encoding)
  
    if (actual !== length) {
      // Writing a hex string, for example, that contains invalid characters will
      // cause everything after the first invalid character to be ignored. (e.g.
      // 'abxxcd' will be treated as 'ab')
      buf = buf.slice(0, actual)
    }
  
    return buf
  }
  
  function fromArrayLike (array) {
    var length = array.length < 0 ? 0 : checked(array.length) | 0
    var buf = createBuffer(length)
    for (var i = 0; i < length; i += 1) {
      buf[i] = array[i] & 255
    }
    return buf
  }
  
  function fromArrayBuffer (array, byteOffset, length) {
    if (byteOffset < 0 || array.byteLength < byteOffset) {
      throw new RangeError('"offset" is outside of buffer bounds')
    }
  
    if (array.byteLength < byteOffset + (length || 0)) {
      throw new RangeError('"length" is outside of buffer bounds')
    }
  
    var buf
    if (byteOffset === undefined && length === undefined) {
      buf = new Uint8Array(array)
    } else if (length === undefined) {
      buf = new Uint8Array(array, byteOffset)
    } else {
      buf = new Uint8Array(array, byteOffset, length)
    }
  
    // Return an augmented `Uint8Array` instance
    buf.__proto__ = Buffer.prototype
    return buf
  }
  
  function fromObject (obj) {
    if (Buffer.isBuffer(obj)) {
      var len = checked(obj.length) | 0
      var buf = createBuffer(len)
  
      if (buf.length === 0) {
        return buf
      }
  
      obj.copy(buf, 0, 0, len)
      return buf
    }
  
    if (obj.length !== undefined) {
      if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
        return createBuffer(0)
      }
      return fromArrayLike(obj)
    }
  
    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
      return fromArrayLike(obj.data)
    }
  }
  
  function checked (length) {
    // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
    // length is NaN (which is otherwise coerced to zero.)
    if (length >= K_MAX_LENGTH) {
      throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                           'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
    }
    return length | 0
  }
  
  function SlowBuffer (length) {
    if (+length != length) { // eslint-disable-line eqeqeq
      length = 0
    }
    return Buffer.alloc(+length)
  }
  
  Buffer.isBuffer = function isBuffer (b) {
    return b != null && b._isBuffer === true &&
      b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
  }
  
  Buffer.compare = function compare (a, b) {
    if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
    if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
    if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
      throw new TypeError(
        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
      )
    }
  
    if (a === b) return 0
  
    var x = a.length
    var y = b.length
  
    for (var i = 0, len = Math.min(x, y); i < len; ++i) {
      if (a[i] !== b[i]) {
        x = a[i]
        y = b[i]
        break
      }
    }
  
    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 'latin1':
      case 'binary':
      case 'base64':
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return true
      default:
        return false
    }
  }
  
  Buffer.concat = function concat (list, length) {
    if (!Array.isArray(list)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
  
    if (list.length === 0) {
      return Buffer.alloc(0)
    }
  
    var i
    if (length === undefined) {
      length = 0
      for (i = 0; i < list.length; ++i) {
        length += list[i].length
      }
    }
  
    var buffer = Buffer.allocUnsafe(length)
    var pos = 0
    for (i = 0; i < list.length; ++i) {
      var buf = list[i]
      if (isInstance(buf, Uint8Array)) {
        buf = Buffer.from(buf)
      }
      if (!Buffer.isBuffer(buf)) {
        throw new TypeError('"list" argument must be an Array of Buffers')
      }
      buf.copy(buffer, pos)
      pos += buf.length
    }
    return buffer
  }
  
  function byteLength (string, encoding) {
    if (Buffer.isBuffer(string)) {
      return string.length
    }
    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
      return string.byteLength
    }
    if (typeof string !== 'string') {
      throw new TypeError(
        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
        'Received type ' + typeof string
      )
    }
  
    var len = string.length
    var mustMatch = (arguments.length > 2 && arguments[2] === true)
    if (!mustMatch && len === 0) return 0
  
    // Use a for loop to avoid recursion
    var loweredCase = false
    for (;;) {
      switch (encoding) {
        case 'ascii':
        case 'latin1':
        case 'binary':
          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 mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
          }
          encoding = ('' + encoding).toLowerCase()
          loweredCase = true
      }
    }
  }
  Buffer.byteLength = byteLength
  
  function slowToString (encoding, start, end) {
    var loweredCase = false
  
    // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
    // property of a typed array.
  
    // This behaves neither like String nor Uint8Array in that we set start/end
    // to their upper/lower bounds if the value passed is out of range.
    // undefined is handled specially as per ECMA-262 6th Edition,
    // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
    if (start === undefined || start < 0) {
      start = 0
    }
    // Return early if start > this.length. Done here to prevent potential uint32
    // coercion fail below.
    if (start > this.length) {
      return ''
    }
  
    if (end === undefined || end > this.length) {
      end = this.length
    }
  
    if (end <= 0) {
      return ''
    }
  
    // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
    end >>>= 0
    start >>>= 0
  
    if (end <= start) {
      return ''
    }
  
    if (!encoding) encoding = 'utf8'
  
    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 'latin1':
        case 'binary':
          return latin1Slice(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
      }
    }
  }
  
  // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
  // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
  // reliably in a browserify context because there could be multiple different
  // copies of the 'buffer' package in use. This method works even for Buffer
  // instances that were created from another copy of the `buffer` package.
  // See: https://github.com/feross/buffer/issues/154
  Buffer.prototype._isBuffer = true
  
  function swap (b, n, m) {
    var i = b[n]
    b[n] = b[m]
    b[m] = i
  }
  
  Buffer.prototype.swap16 = function swap16 () {
    var len = this.length
    if (len % 2 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 16-bits')
    }
    for (var i = 0; i < len; i += 2) {
      swap(this, i, i + 1)
    }
    return this
  }
  
  Buffer.prototype.swap32 = function swap32 () {
    var len = this.length
    if (len % 4 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 32-bits')
    }
    for (var i = 0; i < len; i += 4) {
      swap(this, i, i + 3)
      swap(this, i + 1, i + 2)
    }
    return this
  }
  
  Buffer.prototype.swap64 = function swap64 () {
    var len = this.length
    if (len % 8 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 64-bits')
    }
    for (var i = 0; i < len; i += 8) {
      swap(this, i, i + 7)
      swap(this, i + 1, i + 6)
      swap(this, i + 2, i + 5)
      swap(this, i + 3, i + 4)
    }
    return this
  }
  
  Buffer.prototype.toString = function toString () {
    var length = this.length
    if (length === 0) return ''
    if (arguments.length === 0) return utf8Slice(this, 0, length)
    return slowToString.apply(this, arguments)
  }
  
  Buffer.prototype.toLocaleString = Buffer.prototype.toString
  
  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
    str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
    if (this.length > max) str += ' ... '
    return '<Buffer ' + str + '>'
  }
  
  Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
    if (isInstance(target, Uint8Array)) {
      target = Buffer.from(target, target.offset, target.byteLength)
    }
    if (!Buffer.isBuffer(target)) {
      throw new TypeError(
        'The "target" argument must be one of type Buffer or Uint8Array. ' +
        'Received type ' + (typeof target)
      )
    }
  
    if (start === undefined) {
      start = 0
    }
    if (end === undefined) {
      end = target ? target.length : 0
    }
    if (thisStart === undefined) {
      thisStart = 0
    }
    if (thisEnd === undefined) {
      thisEnd = this.length
    }
  
    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
      throw new RangeError('out of range index')
    }
  
    if (thisStart >= thisEnd && start >= end) {
      return 0
    }
    if (thisStart >= thisEnd) {
      return -1
    }
    if (start >= end) {
      return 1
    }
  
    start >>>= 0
    end >>>= 0
    thisStart >>>= 0
    thisEnd >>>= 0
  
    if (this === target) return 0
  
    var x = thisEnd - thisStart
    var y = end - start
    var len = Math.min(x, y)
  
    var thisCopy = this.slice(thisStart, thisEnd)
    var targetCopy = target.slice(start, end)
  
    for (var i = 0; i < len; ++i) {
      if (thisCopy[i] !== targetCopy[i]) {
        x = thisCopy[i]
        y = targetCopy[i]
        break
      }
    }
  
    if (x < y) return -1
    if (y < x) return 1
    return 0
  }
  
  // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
  // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
  //
  // Arguments:
  // - buffer - a Buffer to search
  // - val - a string, Buffer, or number
  // - byteOffset - an index into `buffer`; will be clamped to an int32
  // - encoding - an optional encoding, relevant is val is a string
  // - dir - true for indexOf, false for lastIndexOf
  function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
    // Empty buffer means no match
    if (buffer.length === 0) return -1
  
    // Normalize byteOffset
    if (typeof byteOffset === 'string') {
      encoding = byteOffset
      byteOffset = 0
    } else if (byteOffset > 0x7fffffff) {
      byteOffset = 0x7fffffff
    } else if (byteOffset < -0x80000000) {
      byteOffset = -0x80000000
    }
    byteOffset = +byteOffset // Coerce to Number.
    if (numberIsNaN(byteOffset)) {
      // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
      byteOffset = dir ? 0 : (buffer.length - 1)
    }
  
    // Normalize byteOffset: negative offsets start from the end of the buffer
    if (byteOffset < 0) byteOffset = buffer.length + byteOffset
    if (byteOffset >= buffer.length) {
      if (dir) return -1
      else byteOffset = buffer.length - 1
    } else if (byteOffset < 0) {
      if (dir) byteOffset = 0
      else return -1
    }
  
    // Normalize val
    if (typeof val === 'string') {
      val = Buffer.from(val, encoding)
    }
  
    // Finally, search either indexOf (if dir is true) or lastIndexOf
    if (Buffer.isBuffer(val)) {
      // Special case: looking for empty string/buffer always fails
      if (val.length === 0) {
        return -1
      }
      return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
    } else if (typeof val === 'number') {
      val = val & 0xFF // Search for a byte value [0-255]
      if (typeof Uint8Array.prototype.indexOf === 'function') {
        if (dir) {
          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
        } else {
          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
        }
      }
      return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
    }
  
    throw new TypeError('val must be string, number or Buffer')
  }
  
  function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
    var indexSize = 1
    var arrLength = arr.length
    var valLength = val.length
  
    if (encoding !== undefined) {
      encoding = String(encoding).toLowerCase()
      if (encoding === 'ucs2' || encoding === 'ucs-2' ||
          encoding === 'utf16le' || encoding === 'utf-16le') {
        if (arr.length < 2 || val.length < 2) {
          return -1
        }
        indexSize = 2
        arrLength /= 2
        valLength /= 2
        byteOffset /= 2
      }
    }
  
    function read (buf, i) {
      if (indexSize === 1) {
        return buf[i]
      } else {
        return buf.readUInt16BE(i * indexSize)
      }
    }
  
    var i
    if (dir) {
      var foundIndex = -1
      for (i = byteOffset; i < arrLength; i++) {
        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
          if (foundIndex === -1) foundIndex = i
          if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
        } else {
          if (foundIndex !== -1) i -= i - foundIndex
          foundIndex = -1
        }
      }
    } else {
      if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
      for (i = byteOffset; i >= 0; i--) {
        var found = true
        for (var j = 0; j < valLength; j++) {
          if (read(arr, i + j) !== read(val, j)) {
            found = false
            break
          }
        }
        if (found) return i
      }
    }
  
    return -1
  }
  
  Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
    return this.indexOf(val, byteOffset, encoding) !== -1
  }
  
  Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
  }
  
  Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
  }
  
  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
      }
    }
  
    var strLen = string.length
  
    if (length > strLen / 2) {
      length = strLen / 2
    }
    for (var i = 0; i < length; ++i) {
      var parsed = parseInt(string.substr(i * 2, 2), 16)
      if (numberIsNaN(parsed)) return i
      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 latin1Write (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
      }
    } else {
      throw new Error(
        'Buffer.write(string, encoding, offset[, length]) is no longer supported'
      )
    }
  
    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 'latin1':
        case 'binary':
          return latin1Write(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 latin1Slice (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 = this.subarray(start, end)
    // Return an augmented `Uint8Array` instance
    newBuf.__proto__ = Buffer.prototype
    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) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 1, this.length)
    return this[offset]
  }
  
  Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    return this[offset] | (this[offset + 1] << 8)
  }
  
  Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    return (this[offset] << 8) | this[offset + 1]
  }
  
  Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    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) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, true, 23, 4)
  }
  
  Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, false, 23, 4)
  }
  
  Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 8, this.length)
    return ieee754.read(this, offset, true, 52, 8)
  }
  
  Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
    offset = offset >>> 0
    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" argument must be a Buffer instance')
    if (value > max || value < min) throw new RangeError('"value" argument 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) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1
      checkInt(this, value, offset, byteLength, maxBytes, 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) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1
      checkInt(this, value, offset, byteLength, maxBytes, 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)
    this[offset] = (value & 0xff)
    return offset + 1
  }
  
  Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    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)
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
    return offset + 2
  }
  
  Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
    this[offset + 3] = (value >>> 24)
    this[offset + 2] = (value >>> 16)
    this[offset + 1] = (value >>> 8)
    this[offset] = (value & 0xff)
    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)
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
    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 = 0
    this[offset] = value & 0xFF
    while (++i < byteLength && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
        sub = 1
      }
      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 = 0
    this[offset + i] = value & 0xFF
    while (--i >= 0 && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
        sub = 1
      }
      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 (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)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    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)
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
    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)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    this[offset + 2] = (value >>> 16)
    this[offset + 3] = (value >>> 24)
    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
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
    return offset + 4
  }
  
  function checkIEEE754 (buf, value, offset, ext, max, min) {
    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) {
    value = +value
    offset = offset >>> 0
    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) {
    value = +value
    offset = offset >>> 0
    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 (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
    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('Index out of range')
    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
  
    if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
      // Use built-in when available, missing from IE11
      this.copyWithin(targetStart, start, end)
    } else if (this === target && start < targetStart && targetStart < end) {
      // descending copy from end
      for (var i = len - 1; i >= 0; --i) {
        target[i + targetStart] = this[i + start]
      }
    } else {
      Uint8Array.prototype.set.call(
        target,
        this.subarray(start, end),
        targetStart
      )
    }
  
    return len
  }
  
  // Usage:
  //    buffer.fill(number[, offset[, end]])
  //    buffer.fill(buffer[, offset[, end]])
  //    buffer.fill(string[, offset[, end]][, encoding])
  Buffer.prototype.fill = function fill (val, start, end, encoding) {
    // Handle string cases:
    if (typeof val === 'string') {
      if (typeof start === 'string') {
        encoding = start
        start = 0
        end = this.length
      } else if (typeof end === 'string') {
        encoding = end
        end = this.length
      }
      if (encoding !== undefined && typeof encoding !== 'string') {
        throw new TypeError('encoding must be a string')
      }
      if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
        throw new TypeError('Unknown encoding: ' + encoding)
      }
      if (val.length === 1) {
        var code = val.charCodeAt(0)
        if ((encoding === 'utf8' && code < 128) ||
            encoding === 'latin1') {
          // Fast path: If `val` fits into a single byte, use that numeric value.
          val = code
        }
      }
    } else if (typeof val === 'number') {
      val = val & 255
    }
  
    // Invalid ranges are not set to a default, so can range check early.
    if (start < 0 || this.length < start || this.length < end) {
      throw new RangeError('Out of range index')
    }
  
    if (end <= start) {
      return this
    }
  
    start = start >>> 0
    end = end === undefined ? this.length : end >>> 0
  
    if (!val) val = 0
  
    var i
    if (typeof val === 'number') {
      for (i = start; i < end; ++i) {
        this[i] = val
      }
    } else {
      var bytes = Buffer.isBuffer(val)
        ? val
        : Buffer.from(val, encoding)
      var len = bytes.length
      if (len === 0) {
        throw new TypeError('The value "' + val +
          '" is invalid for argument "value"')
      }
      for (i = 0; i < end - start; ++i) {
        this[i + start] = bytes[i % len]
      }
    }
  
    return this
  }
  
  // HELPER FUNCTIONS
  // ================
  
  var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
  
  function base64clean (str) {
    // Node takes equal signs as end of the Base64 encoding
    str = str.split('=')[0]
    // Node strips out invalid characters like \n and \t from the string, base64-js does not
    str = str.trim().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 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
  }
  
  // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
  // the `instanceof` check but they should be treated as of that type.
  // See: https://github.com/feross/buffer/issues/166
  function isInstance (obj, type) {
    return obj instanceof type ||
      (obj != null && obj.constructor != null && obj.constructor.name != null &&
        obj.constructor.name === type.name)
  }
  function numberIsNaN (obj) {
    // For IE11 support
    return obj !== obj // eslint-disable-line no-self-compare
  }
  
  },{"base64-js":52,"ieee754":95}],56:[function(require,module,exports){
  module.exports = {
    "100": "Continue",
    "101": "Switching Protocols",
    "102": "Processing",
    "200": "OK",
    "201": "Created",
    "202": "Accepted",
    "203": "Non-Authoritative Information",
    "204": "No Content",
    "205": "Reset Content",
    "206": "Partial Content",
    "207": "Multi-Status",
    "208": "Already Reported",
    "226": "IM Used",
    "300": "Multiple Choices",
    "301": "Moved Permanently",
    "302": "Found",
    "303": "See Other",
    "304": "Not Modified",
    "305": "Use Proxy",
    "307": "Temporary Redirect",
    "308": "Permanent Redirect",
    "400": "Bad Request",
    "401": "Unauthorized",
    "402": "Payment Required",
    "403": "Forbidden",
    "404": "Not Found",
    "405": "Method Not Allowed",
    "406": "Not Acceptable",
    "407": "Proxy Authentication Required",
    "408": "Request Timeout",
    "409": "Conflict",
    "410": "Gone",
    "411": "Length Required",
    "412": "Precondition Failed",
    "413": "Payload Too Large",
    "414": "URI Too Long",
    "415": "Unsupported Media Type",
    "416": "Range Not Satisfiable",
    "417": "Expectation Failed",
    "418": "I'm a teapot",
    "421": "Misdirected Request",
    "422": "Unprocessable Entity",
    "423": "Locked",
    "424": "Failed Dependency",
    "425": "Unordered Collection",
    "426": "Upgrade Required",
    "428": "Precondition Required",
    "429": "Too Many Requests",
    "431": "Request Header Fields Too Large",
    "451": "Unavailable For Legal Reasons",
    "500": "Internal Server Error",
    "501": "Not Implemented",
    "502": "Bad Gateway",
    "503": "Service Unavailable",
    "504": "Gateway Timeout",
    "505": "HTTP Version Not Supported",
    "506": "Variant Also Negotiates",
    "507": "Insufficient Storage",
    "508": "Loop Detected",
    "509": "Bandwidth Limit Exceeded",
    "510": "Not Extended",
    "511": "Network Authentication Required"
  }
  
  },{}],57:[function(require,module,exports){
  /* jshint node: true */
  (function () {
      "use strict";
  
      function CookieAccessInfo(domain, path, secure, script) {
          if (this instanceof CookieAccessInfo) {
              this.domain = domain || undefined;
              this.path = path || "/";
              this.secure = !!secure;
              this.script = !!script;
              return this;
          }
          return new CookieAccessInfo(domain, path, secure, script);
      }
      CookieAccessInfo.All = Object.freeze(Object.create(null));
      exports.CookieAccessInfo = CookieAccessInfo;
  
      function Cookie(cookiestr, request_domain, request_path) {
          if (cookiestr instanceof Cookie) {
              return cookiestr;
          }
          if (this instanceof Cookie) {
              this.name = null;
              this.value = null;
              this.expiration_date = Infinity;
              this.path = String(request_path || "/");
              this.explicit_path = false;
              this.domain = request_domain || null;
              this.explicit_domain = false;
              this.secure = false; //how to define default?
              this.noscript = false; //httponly
              if (cookiestr) {
                  this.parse(cookiestr, request_domain, request_path);
              }
              return this;
          }
          return new Cookie(cookiestr, request_domain, request_path);
      }
      exports.Cookie = Cookie;
  
      Cookie.prototype.toString = function toString() {
          var str = [this.name + "=" + this.value];
          if (this.expiration_date !== Infinity) {
              str.push("expires=" + (new Date(this.expiration_date)).toGMTString());
          }
          if (this.domain) {
              str.push("domain=" + this.domain);
          }
          if (this.path) {
              str.push("path=" + this.path);
          }
          if (this.secure) {
              str.push("secure");
          }
          if (this.noscript) {
              str.push("httponly");
          }
          return str.join("; ");
      };
  
      Cookie.prototype.toValueString = function toValueString() {
          return this.name + "=" + this.value;
      };
  
      var cookie_str_splitter = /[:](?=\s*[a-zA-Z0-9_\-]+\s*[=])/g;
      Cookie.prototype.parse = function parse(str, request_domain, request_path) {
          if (this instanceof Cookie) {
              var parts = str.split(";").filter(function (value) {
                      return !!value;
                  });
              var i;
  
              var pair = parts[0].match(/([^=]+)=([\s\S]*)/);
              if (!pair) {
                  console.warn("Invalid cookie header encountered. Header: '"+str+"'");
                  return;
              }
  
              var key = pair[1];
              var value = pair[2];
              if ( typeof key !== 'string' || key.length === 0 || typeof value !== 'string' ) {
                  console.warn("Unable to extract values from cookie header. Cookie: '"+str+"'");
                  return;
              }
  
              this.name = key;
              this.value = value;
  
              for (i = 1; i < parts.length; i += 1) {
                  pair = parts[i].match(/([^=]+)(?:=([\s\S]*))?/);
                  key = pair[1].trim().toLowerCase();
                  value = pair[2];
                  switch (key) {
                  case "httponly":
                      this.noscript = true;
                      break;
                  case "expires":
                      this.expiration_date = value ?
                              Number(Date.parse(value)) :
                              Infinity;
                      break;
                  case "path":
                      this.path = value ?
                              value.trim() :
                              "";
                      this.explicit_path = true;
                      break;
                  case "domain":
                      this.domain = value ?
                              value.trim() :
                              "";
                      this.explicit_domain = !!this.domain;
                      break;
                  case "secure":
                      this.secure = true;
                      break;
                  }
              }
  
              if (!this.explicit_path) {
                 this.path = request_path || "/";
              }
              if (!this.explicit_domain) {
                 this.domain = request_domain;
              }
  
              return this;
          }
          return new Cookie().parse(str, request_domain, request_path);
      };
  
      Cookie.prototype.matches = function matches(access_info) {
          if (access_info === CookieAccessInfo.All) {
            return true;
          }
          if (this.noscript && access_info.script ||
                  this.secure && !access_info.secure ||
                  !this.collidesWith(access_info)) {
              return false;
          }
          return true;
      };
  
      Cookie.prototype.collidesWith = function collidesWith(access_info) {
          if ((this.path && !access_info.path) || (this.domain && !access_info.domain)) {
              return false;
          }
          if (this.path && access_info.path.indexOf(this.path) !== 0) {
              return false;
          }
          if (this.explicit_path && access_info.path.indexOf( this.path ) !== 0) {
             return false;
          }
          var access_domain = access_info.domain && access_info.domain.replace(/^[\.]/,'');
          var cookie_domain = this.domain && this.domain.replace(/^[\.]/,'');
          if (cookie_domain === access_domain) {
              return true;
          }
          if (cookie_domain) {
              if (!this.explicit_domain) {
                  return false; // we already checked if the domains were exactly the same
              }
              var wildcard = access_domain.indexOf(cookie_domain);
              if (wildcard === -1 || wildcard !== access_domain.length - cookie_domain.length) {
                  return false;
              }
              return true;
          }
          return true;
      };
  
      function CookieJar() {
          var cookies, cookies_list, collidable_cookie;
          if (this instanceof CookieJar) {
              cookies = Object.create(null); //name: [Cookie]
  
              this.setCookie = function setCookie(cookie, request_domain, request_path) {
                  var remove, i;
                  cookie = new Cookie(cookie, request_domain, request_path);
                  //Delete the cookie if the set is past the current time
                  remove = cookie.expiration_date <= Date.now();
                  if (cookies[cookie.name] !== undefined) {
                      cookies_list = cookies[cookie.name];
                      for (i = 0; i < cookies_list.length; i += 1) {
                          collidable_cookie = cookies_list[i];
                          if (collidable_cookie.collidesWith(cookie)) {
                              if (remove) {
                                  cookies_list.splice(i, 1);
                                  if (cookies_list.length === 0) {
                                      delete cookies[cookie.name];
                                  }
                                  return false;
                              }
                              cookies_list[i] = cookie;
                              return cookie;
                          }
                      }
                      if (remove) {
                          return false;
                      }
                      cookies_list.push(cookie);
                      return cookie;
                  }
                  if (remove) {
                      return false;
                  }
                  cookies[cookie.name] = [cookie];
                  return cookies[cookie.name];
              };
              //returns a cookie
              this.getCookie = function getCookie(cookie_name, access_info) {
                  var cookie, i;
                  cookies_list = cookies[cookie_name];
                  if (!cookies_list) {
                      return;
                  }
                  for (i = 0; i < cookies_list.length; i += 1) {
                      cookie = cookies_list[i];
                      if (cookie.expiration_date <= Date.now()) {
                          if (cookies_list.length === 0) {
                              delete cookies[cookie.name];
                          }
                          continue;
                      }
  
                      if (cookie.matches(access_info)) {
                          return cookie;
                      }
                  }
              };
              //returns a list of cookies
              this.getCookies = function getCookies(access_info) {
                  var matches = [], cookie_name, cookie;
                  for (cookie_name in cookies) {
                      cookie = this.getCookie(cookie_name, access_info);
                      if (cookie) {
                          matches.push(cookie);
                      }
                  }
                  matches.toString = function toString() {
                      return matches.join(":");
                  };
                  matches.toValueString = function toValueString() {
                      return matches.map(function (c) {
                          return c.toValueString();
                      }).join(';');
                  };
                  return matches;
              };
  
              return this;
          }
          return new CookieJar();
      }
      exports.CookieJar = CookieJar;
  
      //returns list of cookies that were set correctly. Cookies that are expired and removed are not returned.
      CookieJar.prototype.setCookies = function setCookies(cookies, request_domain, request_path) {
          cookies = Array.isArray(cookies) ?
                  cookies :
                  cookies.split(cookie_str_splitter);
          var successful = [],
              i,
              cookie;
          cookies = cookies.map(function(item){
              return new Cookie(item, request_domain, request_path);
          });
          for (i = 0; i < cookies.length; i += 1) {
              cookie = cookies[i];
              if (this.setCookie(cookie, request_domain, request_path)) {
                  successful.push(cookie);
              }
          }
          return successful;
      };
  }());
  
  },{}],58:[function(require,module,exports){
  (function (Buffer){
  // 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.
  
  // NOTE: These type checking functions intentionally don't use `instanceof`
  // because it is fragile and can be easily faked with `Object.create()`.
  
  function isArray(arg) {
    if (Array.isArray) {
      return Array.isArray(arg);
    }
    return objectToString(arg) === '[object Array]';
  }
  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 === 'symbol';
  }
  exports.isSymbol = isSymbol;
  
  function isUndefined(arg) {
    return arg === void 0;
  }
  exports.isUndefined = isUndefined;
  
  function isRegExp(re) {
    return objectToString(re) === '[object RegExp]';
  }
  exports.isRegExp = isRegExp;
  
  function isObject(arg) {
    return typeof arg === 'object' && arg !== null;
  }
  exports.isObject = isObject;
  
  function isDate(d) {
    return objectToString(d) === '[object Date]';
  }
  exports.isDate = isDate;
  
  function isError(e) {
    return (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 === 'symbol' ||  // ES6 symbol
           typeof arg === 'undefined';
  }
  exports.isPrimitive = isPrimitive;
  
  exports.isBuffer = Buffer.isBuffer;
  
  function objectToString(o) {
    return Object.prototype.toString.call(o);
  }
  
  }).call(this,{"isBuffer":require("../../is-buffer/index.js")})
  
  },{"../../is-buffer/index.js":97}],59:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var BlockCipher = C_lib.BlockCipher;
  	    var C_algo = C.algo;
  
  	    // Lookup tables
  	    var SBOX = [];
  	    var INV_SBOX = [];
  	    var SUB_MIX_0 = [];
  	    var SUB_MIX_1 = [];
  	    var SUB_MIX_2 = [];
  	    var SUB_MIX_3 = [];
  	    var INV_SUB_MIX_0 = [];
  	    var INV_SUB_MIX_1 = [];
  	    var INV_SUB_MIX_2 = [];
  	    var INV_SUB_MIX_3 = [];
  
  	    // Compute lookup tables
  	    (function () {
  	        // Compute double table
  	        var d = [];
  	        for (var i = 0; i < 256; i++) {
  	            if (i < 128) {
  	                d[i] = i << 1;
  	            } else {
  	                d[i] = (i << 1) ^ 0x11b;
  	            }
  	        }
  
  	        // Walk GF(2^8)
  	        var x = 0;
  	        var xi = 0;
  	        for (var i = 0; i < 256; i++) {
  	            // Compute sbox
  	            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
  	            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
  	            SBOX[x] = sx;
  	            INV_SBOX[sx] = x;
  
  	            // Compute multiplication
  	            var x2 = d[x];
  	            var x4 = d[x2];
  	            var x8 = d[x4];
  
  	            // Compute sub bytes, mix columns tables
  	            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
  	            SUB_MIX_0[x] = (t << 24) | (t >>> 8);
  	            SUB_MIX_1[x] = (t << 16) | (t >>> 16);
  	            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
  	            SUB_MIX_3[x] = t;
  
  	            // Compute inv sub bytes, inv mix columns tables
  	            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
  	            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
  	            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
  	            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
  	            INV_SUB_MIX_3[sx] = t;
  
  	            // Compute next counter
  	            if (!x) {
  	                x = xi = 1;
  	            } else {
  	                x = x2 ^ d[d[d[x8 ^ x2]]];
  	                xi ^= d[d[xi]];
  	            }
  	        }
  	    }());
  
  	    // Precomputed Rcon lookup
  	    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
  
  	    /**
  	     * AES block cipher algorithm.
  	     */
  	    var AES = C_algo.AES = BlockCipher.extend({
  	        _doReset: function () {
  	            // Skip reset of nRounds has been set before and key did not change
  	            if (this._nRounds && this._keyPriorReset === this._key) {
  	                return;
  	            }
  
  	            // Shortcuts
  	            var key = this._keyPriorReset = this._key;
  	            var keyWords = key.words;
  	            var keySize = key.sigBytes / 4;
  
  	            // Compute number of rounds
  	            var nRounds = this._nRounds = keySize + 6;
  
  	            // Compute number of key schedule rows
  	            var ksRows = (nRounds + 1) * 4;
  
  	            // Compute key schedule
  	            var keySchedule = this._keySchedule = [];
  	            for (var ksRow = 0; ksRow < ksRows; ksRow++) {
  	                if (ksRow < keySize) {
  	                    keySchedule[ksRow] = keyWords[ksRow];
  	                } else {
  	                    var t = keySchedule[ksRow - 1];
  
  	                    if (!(ksRow % keySize)) {
  	                        // Rot word
  	                        t = (t << 8) | (t >>> 24);
  
  	                        // Sub word
  	                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  
  	                        // Mix Rcon
  	                        t ^= RCON[(ksRow / keySize) | 0] << 24;
  	                    } else if (keySize > 6 && ksRow % keySize == 4) {
  	                        // Sub word
  	                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
  	                    }
  
  	                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
  	                }
  	            }
  
  	            // Compute inv key schedule
  	            var invKeySchedule = this._invKeySchedule = [];
  	            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
  	                var ksRow = ksRows - invKsRow;
  
  	                if (invKsRow % 4) {
  	                    var t = keySchedule[ksRow];
  	                } else {
  	                    var t = keySchedule[ksRow - 4];
  	                }
  
  	                if (invKsRow < 4 || ksRow <= 4) {
  	                    invKeySchedule[invKsRow] = t;
  	                } else {
  	                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
  	                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
  	                }
  	            }
  	        },
  
  	        encryptBlock: function (M, offset) {
  	            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
  	        },
  
  	        decryptBlock: function (M, offset) {
  	            // Swap 2nd and 4th rows
  	            var t = M[offset + 1];
  	            M[offset + 1] = M[offset + 3];
  	            M[offset + 3] = t;
  
  	            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
  
  	            // Inv swap 2nd and 4th rows
  	            var t = M[offset + 1];
  	            M[offset + 1] = M[offset + 3];
  	            M[offset + 3] = t;
  	        },
  
  	        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
  	            // Shortcut
  	            var nRounds = this._nRounds;
  
  	            // Get input, add round key
  	            var s0 = M[offset]     ^ keySchedule[0];
  	            var s1 = M[offset + 1] ^ keySchedule[1];
  	            var s2 = M[offset + 2] ^ keySchedule[2];
  	            var s3 = M[offset + 3] ^ keySchedule[3];
  
  	            // Key schedule row counter
  	            var ksRow = 4;
  
  	            // Rounds
  	            for (var round = 1; round < nRounds; round++) {
  	                // Shift rows, sub bytes, mix columns, add round key
  	                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
  	                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
  	                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
  	                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
  
  	                // Update state
  	                s0 = t0;
  	                s1 = t1;
  	                s2 = t2;
  	                s3 = t3;
  	            }
  
  	            // Shift rows, sub bytes, add round key
  	            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
  	            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
  	            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
  	            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
  
  	            // Set output
  	            M[offset]     = t0;
  	            M[offset + 1] = t1;
  	            M[offset + 2] = t2;
  	            M[offset + 3] = t3;
  	        },
  
  	        keySize: 256/32
  	    });
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
  	     */
  	    C.AES = BlockCipher._createHelper(AES);
  	}());
  
  
  	return CryptoJS.AES;
  
  }));
  },{"./cipher-core":60,"./core":61,"./enc-base64":62,"./evpkdf":64,"./md5":69}],60:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Cipher core components.
  	 */
  	CryptoJS.lib.Cipher || (function (undefined) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Base = C_lib.Base;
  	    var WordArray = C_lib.WordArray;
  	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
  	    var C_enc = C.enc;
  	    var Utf8 = C_enc.Utf8;
  	    var Base64 = C_enc.Base64;
  	    var C_algo = C.algo;
  	    var EvpKDF = C_algo.EvpKDF;
  
  	    /**
  	     * Abstract base cipher template.
  	     *
  	     * @property {number} keySize This cipher's key size. Default: 4 (128 bits)
  	     * @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
  	     * @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
  	     * @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
  	     */
  	    var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {WordArray} iv The IV to use for this operation.
  	         */
  	        cfg: Base.extend(),
  
  	        /**
  	         * Creates this cipher in encryption mode.
  	         *
  	         * @param {WordArray} key The key.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {Cipher} A cipher instance.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
  	         */
  	        createEncryptor: function (key, cfg) {
  	            return this.create(this._ENC_XFORM_MODE, key, cfg);
  	        },
  
  	        /**
  	         * Creates this cipher in decryption mode.
  	         *
  	         * @param {WordArray} key The key.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {Cipher} A cipher instance.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
  	         */
  	        createDecryptor: function (key, cfg) {
  	            return this.create(this._DEC_XFORM_MODE, key, cfg);
  	        },
  
  	        /**
  	         * Initializes a newly created cipher.
  	         *
  	         * @param {number} xformMode Either the encryption or decryption transormation mode constant.
  	         * @param {WordArray} key The key.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @example
  	         *
  	         *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
  	         */
  	        init: function (xformMode, key, cfg) {
  	            // Apply config defaults
  	            this.cfg = this.cfg.extend(cfg);
  
  	            // Store transform mode and key
  	            this._xformMode = xformMode;
  	            this._key = key;
  
  	            // Set initial values
  	            this.reset();
  	        },
  
  	        /**
  	         * Resets this cipher to its initial state.
  	         *
  	         * @example
  	         *
  	         *     cipher.reset();
  	         */
  	        reset: function () {
  	            // Reset data buffer
  	            BufferedBlockAlgorithm.reset.call(this);
  
  	            // Perform concrete-cipher logic
  	            this._doReset();
  	        },
  
  	        /**
  	         * Adds data to be encrypted or decrypted.
  	         *
  	         * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
  	         *
  	         * @return {WordArray} The data after processing.
  	         *
  	         * @example
  	         *
  	         *     var encrypted = cipher.process('data');
  	         *     var encrypted = cipher.process(wordArray);
  	         */
  	        process: function (dataUpdate) {
  	            // Append
  	            this._append(dataUpdate);
  
  	            // Process available blocks
  	            return this._process();
  	        },
  
  	        /**
  	         * Finalizes the encryption or decryption process.
  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  	         *
  	         * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
  	         *
  	         * @return {WordArray} The data after final processing.
  	         *
  	         * @example
  	         *
  	         *     var encrypted = cipher.finalize();
  	         *     var encrypted = cipher.finalize('data');
  	         *     var encrypted = cipher.finalize(wordArray);
  	         */
  	        finalize: function (dataUpdate) {
  	            // Final data update
  	            if (dataUpdate) {
  	                this._append(dataUpdate);
  	            }
  
  	            // Perform concrete-cipher logic
  	            var finalProcessedData = this._doFinalize();
  
  	            return finalProcessedData;
  	        },
  
  	        keySize: 128/32,
  
  	        ivSize: 128/32,
  
  	        _ENC_XFORM_MODE: 1,
  
  	        _DEC_XFORM_MODE: 2,
  
  	        /**
  	         * Creates shortcut functions to a cipher's object interface.
  	         *
  	         * @param {Cipher} cipher The cipher to create a helper for.
  	         *
  	         * @return {Object} An object with encrypt and decrypt shortcut functions.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
  	         */
  	        _createHelper: (function () {
  	            function selectCipherStrategy(key) {
  	                if (typeof key == 'string') {
  	                    return PasswordBasedCipher;
  	                } else {
  	                    return SerializableCipher;
  	                }
  	            }
  
  	            return function (cipher) {
  	                return {
  	                    encrypt: function (message, key, cfg) {
  	                        return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
  	                    },
  
  	                    decrypt: function (ciphertext, key, cfg) {
  	                        return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
  	                    }
  	                };
  	            };
  	        }())
  	    });
  
  	    /**
  	     * Abstract base stream cipher template.
  	     *
  	     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
  	     */
  	    var StreamCipher = C_lib.StreamCipher = Cipher.extend({
  	        _doFinalize: function () {
  	            // Process partial blocks
  	            var finalProcessedBlocks = this._process(!!'flush');
  
  	            return finalProcessedBlocks;
  	        },
  
  	        blockSize: 1
  	    });
  
  	    /**
  	     * Mode namespace.
  	     */
  	    var C_mode = C.mode = {};
  
  	    /**
  	     * Abstract base block cipher mode template.
  	     */
  	    var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
  	        /**
  	         * Creates this mode for encryption.
  	         *
  	         * @param {Cipher} cipher A block cipher instance.
  	         * @param {Array} iv The IV words.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
  	         */
  	        createEncryptor: function (cipher, iv) {
  	            return this.Encryptor.create(cipher, iv);
  	        },
  
  	        /**
  	         * Creates this mode for decryption.
  	         *
  	         * @param {Cipher} cipher A block cipher instance.
  	         * @param {Array} iv The IV words.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
  	         */
  	        createDecryptor: function (cipher, iv) {
  	            return this.Decryptor.create(cipher, iv);
  	        },
  
  	        /**
  	         * Initializes a newly created mode.
  	         *
  	         * @param {Cipher} cipher A block cipher instance.
  	         * @param {Array} iv The IV words.
  	         *
  	         * @example
  	         *
  	         *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
  	         */
  	        init: function (cipher, iv) {
  	            this._cipher = cipher;
  	            this._iv = iv;
  	        }
  	    });
  
  	    /**
  	     * Cipher Block Chaining mode.
  	     */
  	    var CBC = C_mode.CBC = (function () {
  	        /**
  	         * Abstract base CBC mode.
  	         */
  	        var CBC = BlockCipherMode.extend();
  
  	        /**
  	         * CBC encryptor.
  	         */
  	        CBC.Encryptor = CBC.extend({
  	            /**
  	             * Processes the data block at offset.
  	             *
  	             * @param {Array} words The data words to operate on.
  	             * @param {number} offset The offset where the block starts.
  	             *
  	             * @example
  	             *
  	             *     mode.processBlock(data.words, offset);
  	             */
  	            processBlock: function (words, offset) {
  	                // Shortcuts
  	                var cipher = this._cipher;
  	                var blockSize = cipher.blockSize;
  
  	                // XOR and encrypt
  	                xorBlock.call(this, words, offset, blockSize);
  	                cipher.encryptBlock(words, offset);
  
  	                // Remember this block to use with next block
  	                this._prevBlock = words.slice(offset, offset + blockSize);
  	            }
  	        });
  
  	        /**
  	         * CBC decryptor.
  	         */
  	        CBC.Decryptor = CBC.extend({
  	            /**
  	             * Processes the data block at offset.
  	             *
  	             * @param {Array} words The data words to operate on.
  	             * @param {number} offset The offset where the block starts.
  	             *
  	             * @example
  	             *
  	             *     mode.processBlock(data.words, offset);
  	             */
  	            processBlock: function (words, offset) {
  	                // Shortcuts
  	                var cipher = this._cipher;
  	                var blockSize = cipher.blockSize;
  
  	                // Remember this block to use with next block
  	                var thisBlock = words.slice(offset, offset + blockSize);
  
  	                // Decrypt and XOR
  	                cipher.decryptBlock(words, offset);
  	                xorBlock.call(this, words, offset, blockSize);
  
  	                // This block becomes the previous block
  	                this._prevBlock = thisBlock;
  	            }
  	        });
  
  	        function xorBlock(words, offset, blockSize) {
  	            // Shortcut
  	            var iv = this._iv;
  
  	            // Choose mixing block
  	            if (iv) {
  	                var block = iv;
  
  	                // Remove IV for subsequent blocks
  	                this._iv = undefined;
  	            } else {
  	                var block = this._prevBlock;
  	            }
  
  	            // XOR blocks
  	            for (var i = 0; i < blockSize; i++) {
  	                words[offset + i] ^= block[i];
  	            }
  	        }
  
  	        return CBC;
  	    }());
  
  	    /**
  	     * Padding namespace.
  	     */
  	    var C_pad = C.pad = {};
  
  	    /**
  	     * PKCS #5/7 padding strategy.
  	     */
  	    var Pkcs7 = C_pad.Pkcs7 = {
  	        /**
  	         * Pads data using the algorithm defined in PKCS #5/7.
  	         *
  	         * @param {WordArray} data The data to pad.
  	         * @param {number} blockSize The multiple that the data should be padded to.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
  	         */
  	        pad: function (data, blockSize) {
  	            // Shortcut
  	            var blockSizeBytes = blockSize * 4;
  
  	            // Count padding bytes
  	            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
  
  	            // Create padding word
  	            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
  
  	            // Create padding
  	            var paddingWords = [];
  	            for (var i = 0; i < nPaddingBytes; i += 4) {
  	                paddingWords.push(paddingWord);
  	            }
  	            var padding = WordArray.create(paddingWords, nPaddingBytes);
  
  	            // Add padding
  	            data.concat(padding);
  	        },
  
  	        /**
  	         * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
  	         *
  	         * @param {WordArray} data The data to unpad.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     CryptoJS.pad.Pkcs7.unpad(wordArray);
  	         */
  	        unpad: function (data) {
  	            // Get number of padding bytes from last byte
  	            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
  
  	            // Remove padding
  	            data.sigBytes -= nPaddingBytes;
  	        }
  	    };
  
  	    /**
  	     * Abstract base block cipher template.
  	     *
  	     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
  	     */
  	    var BlockCipher = C_lib.BlockCipher = Cipher.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {Mode} mode The block mode to use. Default: CBC
  	         * @property {Padding} padding The padding strategy to use. Default: Pkcs7
  	         */
  	        cfg: Cipher.cfg.extend({
  	            mode: CBC,
  	            padding: Pkcs7
  	        }),
  
  	        reset: function () {
  	            // Reset cipher
  	            Cipher.reset.call(this);
  
  	            // Shortcuts
  	            var cfg = this.cfg;
  	            var iv = cfg.iv;
  	            var mode = cfg.mode;
  
  	            // Reset block mode
  	            if (this._xformMode == this._ENC_XFORM_MODE) {
  	                var modeCreator = mode.createEncryptor;
  	            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
  	                var modeCreator = mode.createDecryptor;
  
  	                // Keep at least one block in the buffer for unpadding
  	                this._minBufferSize = 1;
  	            }
  	            this._mode = modeCreator.call(mode, this, iv && iv.words);
  	        },
  
  	        _doProcessBlock: function (words, offset) {
  	            this._mode.processBlock(words, offset);
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcut
  	            var padding = this.cfg.padding;
  
  	            // Finalize
  	            if (this._xformMode == this._ENC_XFORM_MODE) {
  	                // Pad data
  	                padding.pad(this._data, this.blockSize);
  
  	                // Process final blocks
  	                var finalProcessedBlocks = this._process(!!'flush');
  	            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
  	                // Process final blocks
  	                var finalProcessedBlocks = this._process(!!'flush');
  
  	                // Unpad data
  	                padding.unpad(finalProcessedBlocks);
  	            }
  
  	            return finalProcessedBlocks;
  	        },
  
  	        blockSize: 128/32
  	    });
  
  	    /**
  	     * A collection of cipher parameters.
  	     *
  	     * @property {WordArray} ciphertext The raw ciphertext.
  	     * @property {WordArray} key The key to this ciphertext.
  	     * @property {WordArray} iv The IV used in the ciphering operation.
  	     * @property {WordArray} salt The salt used with a key derivation function.
  	     * @property {Cipher} algorithm The cipher algorithm.
  	     * @property {Mode} mode The block mode used in the ciphering operation.
  	     * @property {Padding} padding The padding scheme used in the ciphering operation.
  	     * @property {number} blockSize The block size of the cipher.
  	     * @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
  	     */
  	    var CipherParams = C_lib.CipherParams = Base.extend({
  	        /**
  	         * Initializes a newly created cipher params object.
  	         *
  	         * @param {Object} cipherParams An object with any of the possible cipher parameters.
  	         *
  	         * @example
  	         *
  	         *     var cipherParams = CryptoJS.lib.CipherParams.create({
  	         *         ciphertext: ciphertextWordArray,
  	         *         key: keyWordArray,
  	         *         iv: ivWordArray,
  	         *         salt: saltWordArray,
  	         *         algorithm: CryptoJS.algo.AES,
  	         *         mode: CryptoJS.mode.CBC,
  	         *         padding: CryptoJS.pad.PKCS7,
  	         *         blockSize: 4,
  	         *         formatter: CryptoJS.format.OpenSSL
  	         *     });
  	         */
  	        init: function (cipherParams) {
  	            this.mixIn(cipherParams);
  	        },
  
  	        /**
  	         * Converts this cipher params object to a string.
  	         *
  	         * @param {Format} formatter (Optional) The formatting strategy to use.
  	         *
  	         * @return {string} The stringified cipher params.
  	         *
  	         * @throws Error If neither the formatter nor the default formatter is set.
  	         *
  	         * @example
  	         *
  	         *     var string = cipherParams + '';
  	         *     var string = cipherParams.toString();
  	         *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
  	         */
  	        toString: function (formatter) {
  	            return (formatter || this.formatter).stringify(this);
  	        }
  	    });
  
  	    /**
  	     * Format namespace.
  	     */
  	    var C_format = C.format = {};
  
  	    /**
  	     * OpenSSL formatting strategy.
  	     */
  	    var OpenSSLFormatter = C_format.OpenSSL = {
  	        /**
  	         * Converts a cipher params object to an OpenSSL-compatible string.
  	         *
  	         * @param {CipherParams} cipherParams The cipher params object.
  	         *
  	         * @return {string} The OpenSSL-compatible string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
  	         */
  	        stringify: function (cipherParams) {
  	            // Shortcuts
  	            var ciphertext = cipherParams.ciphertext;
  	            var salt = cipherParams.salt;
  
  	            // Format
  	            if (salt) {
  	                var wordArray = WordArray.create([0x53616c74, 0x65645f5f]).concat(salt).concat(ciphertext);
  	            } else {
  	                var wordArray = ciphertext;
  	            }
  
  	            return wordArray.toString(Base64);
  	        },
  
  	        /**
  	         * Converts an OpenSSL-compatible string to a cipher params object.
  	         *
  	         * @param {string} openSSLStr The OpenSSL-compatible string.
  	         *
  	         * @return {CipherParams} The cipher params object.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
  	         */
  	        parse: function (openSSLStr) {
  	            // Parse base64
  	            var ciphertext = Base64.parse(openSSLStr);
  
  	            // Shortcut
  	            var ciphertextWords = ciphertext.words;
  
  	            // Test for salt
  	            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
  	                // Extract salt
  	                var salt = WordArray.create(ciphertextWords.slice(2, 4));
  
  	                // Remove salt from ciphertext
  	                ciphertextWords.splice(0, 4);
  	                ciphertext.sigBytes -= 16;
  	            }
  
  	            return CipherParams.create({ ciphertext: ciphertext, salt: salt });
  	        }
  	    };
  
  	    /**
  	     * A cipher wrapper that returns ciphertext as a serializable cipher params object.
  	     */
  	    var SerializableCipher = C_lib.SerializableCipher = Base.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
  	         */
  	        cfg: Base.extend({
  	            format: OpenSSLFormatter
  	        }),
  
  	        /**
  	         * Encrypts a message.
  	         *
  	         * @param {Cipher} cipher The cipher algorithm to use.
  	         * @param {WordArray|string} message The message to encrypt.
  	         * @param {WordArray} key The key.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {CipherParams} A cipher params object.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  	         */
  	        encrypt: function (cipher, message, key, cfg) {
  	            // Apply config defaults
  	            cfg = this.cfg.extend(cfg);
  
  	            // Encrypt
  	            var encryptor = cipher.createEncryptor(key, cfg);
  	            var ciphertext = encryptor.finalize(message);
  
  	            // Shortcut
  	            var cipherCfg = encryptor.cfg;
  
  	            // Create and return serializable cipher params
  	            return CipherParams.create({
  	                ciphertext: ciphertext,
  	                key: key,
  	                iv: cipherCfg.iv,
  	                algorithm: cipher,
  	                mode: cipherCfg.mode,
  	                padding: cipherCfg.padding,
  	                blockSize: cipher.blockSize,
  	                formatter: cfg.format
  	            });
  	        },
  
  	        /**
  	         * Decrypts serialized ciphertext.
  	         *
  	         * @param {Cipher} cipher The cipher algorithm to use.
  	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
  	         * @param {WordArray} key The key.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {WordArray} The plaintext.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  	         *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
  	         */
  	        decrypt: function (cipher, ciphertext, key, cfg) {
  	            // Apply config defaults
  	            cfg = this.cfg.extend(cfg);
  
  	            // Convert string to CipherParams
  	            ciphertext = this._parse(ciphertext, cfg.format);
  
  	            // Decrypt
  	            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
  
  	            return plaintext;
  	        },
  
  	        /**
  	         * Converts serialized ciphertext to CipherParams,
  	         * else assumed CipherParams already and returns ciphertext unchanged.
  	         *
  	         * @param {CipherParams|string} ciphertext The ciphertext.
  	         * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
  	         *
  	         * @return {CipherParams} The unserialized ciphertext.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
  	         */
  	        _parse: function (ciphertext, format) {
  	            if (typeof ciphertext == 'string') {
  	                return format.parse(ciphertext, this);
  	            } else {
  	                return ciphertext;
  	            }
  	        }
  	    });
  
  	    /**
  	     * Key derivation function namespace.
  	     */
  	    var C_kdf = C.kdf = {};
  
  	    /**
  	     * OpenSSL key derivation function.
  	     */
  	    var OpenSSLKdf = C_kdf.OpenSSL = {
  	        /**
  	         * Derives a key and IV from a password.
  	         *
  	         * @param {string} password The password to derive from.
  	         * @param {number} keySize The size in words of the key to generate.
  	         * @param {number} ivSize The size in words of the IV to generate.
  	         * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
  	         *
  	         * @return {CipherParams} A cipher params object with the key, IV, and salt.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
  	         *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
  	         */
  	        execute: function (password, keySize, ivSize, salt) {
  	            // Generate random salt
  	            if (!salt) {
  	                salt = WordArray.random(64/8);
  	            }
  
  	            // Derive key and IV
  	            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
  
  	            // Separate key and IV
  	            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
  	            key.sigBytes = keySize * 4;
  
  	            // Return params
  	            return CipherParams.create({ key: key, iv: iv, salt: salt });
  	        }
  	    };
  
  	    /**
  	     * A serializable cipher wrapper that derives the key from a password,
  	     * and returns ciphertext as a serializable cipher params object.
  	     */
  	    var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
  	         */
  	        cfg: SerializableCipher.cfg.extend({
  	            kdf: OpenSSLKdf
  	        }),
  
  	        /**
  	         * Encrypts a message using a password.
  	         *
  	         * @param {Cipher} cipher The cipher algorithm to use.
  	         * @param {WordArray|string} message The message to encrypt.
  	         * @param {string} password The password.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {CipherParams} A cipher params object.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
  	         *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
  	         */
  	        encrypt: function (cipher, message, password, cfg) {
  	            // Apply config defaults
  	            cfg = this.cfg.extend(cfg);
  
  	            // Derive key and other params
  	            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
  
  	            // Add IV to config
  	            cfg.iv = derivedParams.iv;
  
  	            // Encrypt
  	            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
  
  	            // Mix in derived params
  	            ciphertext.mixIn(derivedParams);
  
  	            return ciphertext;
  	        },
  
  	        /**
  	         * Decrypts serialized ciphertext using a password.
  	         *
  	         * @param {Cipher} cipher The cipher algorithm to use.
  	         * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
  	         * @param {string} password The password.
  	         * @param {Object} cfg (Optional) The configuration options to use for this operation.
  	         *
  	         * @return {WordArray} The plaintext.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
  	         *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
  	         */
  	        decrypt: function (cipher, ciphertext, password, cfg) {
  	            // Apply config defaults
  	            cfg = this.cfg.extend(cfg);
  
  	            // Convert string to CipherParams
  	            ciphertext = this._parse(ciphertext, cfg.format);
  
  	            // Derive key and other params
  	            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
  
  	            // Add IV to config
  	            cfg.iv = derivedParams.iv;
  
  	            // Decrypt
  	            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
  
  	            return plaintext;
  	        }
  	    });
  	}());
  
  
  }));
  },{"./core":61}],61:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory();
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define([], factory);
  	}
  	else {
  		// Global (browser)
  		root.CryptoJS = factory();
  	}
  }(this, function () {
  
  	/**
  	 * CryptoJS core components.
  	 */
  	var CryptoJS = CryptoJS || (function (Math, undefined) {
  	    /*
  	     * Local polyfil of Object.create
  	     */
  	    var create = Object.create || (function () {
  	        function F() {};
  
  	        return function (obj) {
  	            var subtype;
  
  	            F.prototype = obj;
  
  	            subtype = new F();
  
  	            F.prototype = null;
  
  	            return subtype;
  	        };
  	    }())
  
  	    /**
  	     * CryptoJS namespace.
  	     */
  	    var C = {};
  
  	    /**
  	     * Library namespace.
  	     */
  	    var C_lib = C.lib = {};
  
  	    /**
  	     * Base object for prototypal inheritance.
  	     */
  	    var Base = C_lib.Base = (function () {
  
  
  	        return {
  	            /**
  	             * Creates a new object that inherits from this object.
  	             *
  	             * @param {Object} overrides Properties to copy into the new object.
  	             *
  	             * @return {Object} The new object.
  	             *
  	             * @static
  	             *
  	             * @example
  	             *
  	             *     var MyType = CryptoJS.lib.Base.extend({
  	             *         field: 'value',
  	             *
  	             *         method: function () {
  	             *         }
  	             *     });
  	             */
  	            extend: function (overrides) {
  	                // Spawn
  	                var subtype = create(this);
  
  	                // Augment
  	                if (overrides) {
  	                    subtype.mixIn(overrides);
  	                }
  
  	                // Create default initializer
  	                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
  	                    subtype.init = function () {
  	                        subtype.$super.init.apply(this, arguments);
  	                    };
  	                }
  
  	                // Initializer's prototype is the subtype object
  	                subtype.init.prototype = subtype;
  
  	                // Reference supertype
  	                subtype.$super = this;
  
  	                return subtype;
  	            },
  
  	            /**
  	             * Extends this object and runs the init method.
  	             * Arguments to create() will be passed to init().
  	             *
  	             * @return {Object} The new object.
  	             *
  	             * @static
  	             *
  	             * @example
  	             *
  	             *     var instance = MyType.create();
  	             */
  	            create: function () {
  	                var instance = this.extend();
  	                instance.init.apply(instance, arguments);
  
  	                return instance;
  	            },
  
  	            /**
  	             * Initializes a newly created object.
  	             * Override this method to add some logic when your objects are created.
  	             *
  	             * @example
  	             *
  	             *     var MyType = CryptoJS.lib.Base.extend({
  	             *         init: function () {
  	             *             // ...
  	             *         }
  	             *     });
  	             */
  	            init: function () {
  	            },
  
  	            /**
  	             * Copies properties into this object.
  	             *
  	             * @param {Object} properties The properties to mix in.
  	             *
  	             * @example
  	             *
  	             *     MyType.mixIn({
  	             *         field: 'value'
  	             *     });
  	             */
  	            mixIn: function (properties) {
  	                for (var propertyName in properties) {
  	                    if (properties.hasOwnProperty(propertyName)) {
  	                        this[propertyName] = properties[propertyName];
  	                    }
  	                }
  
  	                // IE won't copy toString using the loop above
  	                if (properties.hasOwnProperty('toString')) {
  	                    this.toString = properties.toString;
  	                }
  	            },
  
  	            /**
  	             * Creates a copy of this object.
  	             *
  	             * @return {Object} The clone.
  	             *
  	             * @example
  	             *
  	             *     var clone = instance.clone();
  	             */
  	            clone: function () {
  	                return this.init.prototype.extend(this);
  	            }
  	        };
  	    }());
  
  	    /**
  	     * An array of 32-bit words.
  	     *
  	     * @property {Array} words The array of 32-bit words.
  	     * @property {number} sigBytes The number of significant bytes in this word array.
  	     */
  	    var WordArray = C_lib.WordArray = Base.extend({
  	        /**
  	         * Initializes a newly created word array.
  	         *
  	         * @param {Array} words (Optional) An array of 32-bit words.
  	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.lib.WordArray.create();
  	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
  	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
  	         */
  	        init: function (words, sigBytes) {
  	            words = this.words = words || [];
  
  	            if (sigBytes != undefined) {
  	                this.sigBytes = sigBytes;
  	            } else {
  	                this.sigBytes = words.length * 4;
  	            }
  	        },
  
  	        /**
  	         * Converts this word array to a string.
  	         *
  	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
  	         *
  	         * @return {string} The stringified word array.
  	         *
  	         * @example
  	         *
  	         *     var string = wordArray + '';
  	         *     var string = wordArray.toString();
  	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
  	         */
  	        toString: function (encoder) {
  	            return (encoder || Hex).stringify(this);
  	        },
  
  	        /**
  	         * Concatenates a word array to this word array.
  	         *
  	         * @param {WordArray} wordArray The word array to append.
  	         *
  	         * @return {WordArray} This word array.
  	         *
  	         * @example
  	         *
  	         *     wordArray1.concat(wordArray2);
  	         */
  	        concat: function (wordArray) {
  	            // Shortcuts
  	            var thisWords = this.words;
  	            var thatWords = wordArray.words;
  	            var thisSigBytes = this.sigBytes;
  	            var thatSigBytes = wordArray.sigBytes;
  
  	            // Clamp excess bits
  	            this.clamp();
  
  	            // Concat
  	            if (thisSigBytes % 4) {
  	                // Copy one byte at a time
  	                for (var i = 0; i < thatSigBytes; i++) {
  	                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  	                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
  	                }
  	            } else {
  	                // Copy one word at a time
  	                for (var i = 0; i < thatSigBytes; i += 4) {
  	                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
  	                }
  	            }
  	            this.sigBytes += thatSigBytes;
  
  	            // Chainable
  	            return this;
  	        },
  
  	        /**
  	         * Removes insignificant bits.
  	         *
  	         * @example
  	         *
  	         *     wordArray.clamp();
  	         */
  	        clamp: function () {
  	            // Shortcuts
  	            var words = this.words;
  	            var sigBytes = this.sigBytes;
  
  	            // Clamp
  	            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
  	            words.length = Math.ceil(sigBytes / 4);
  	        },
  
  	        /**
  	         * Creates a copy of this word array.
  	         *
  	         * @return {WordArray} The clone.
  	         *
  	         * @example
  	         *
  	         *     var clone = wordArray.clone();
  	         */
  	        clone: function () {
  	            var clone = Base.clone.call(this);
  	            clone.words = this.words.slice(0);
  
  	            return clone;
  	        },
  
  	        /**
  	         * Creates a word array filled with random bytes.
  	         *
  	         * @param {number} nBytes The number of random bytes to generate.
  	         *
  	         * @return {WordArray} The random word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
  	         */
  	        random: function (nBytes) {
  	            var words = [];
  
  	            var r = (function (m_w) {
  	                var m_w = m_w;
  	                var m_z = 0x3ade68b1;
  	                var mask = 0xffffffff;
  
  	                return function () {
  	                    m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
  	                    m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
  	                    var result = ((m_z << 0x10) + m_w) & mask;
  	                    result /= 0x100000000;
  	                    result += 0.5;
  	                    return result * (Math.random() > .5 ? 1 : -1);
  	                }
  	            });
  
  	            for (var i = 0, rcache; i < nBytes; i += 4) {
  	                var _r = r((rcache || Math.random()) * 0x100000000);
  
  	                rcache = _r() * 0x3ade67b7;
  	                words.push((_r() * 0x100000000) | 0);
  	            }
  
  	            return new WordArray.init(words, nBytes);
  	        }
  	    });
  
  	    /**
  	     * Encoder namespace.
  	     */
  	    var C_enc = C.enc = {};
  
  	    /**
  	     * Hex encoding strategy.
  	     */
  	    var Hex = C_enc.Hex = {
  	        /**
  	         * Converts a word array to a hex string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The hex string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            // Shortcuts
  	            var words = wordArray.words;
  	            var sigBytes = wordArray.sigBytes;
  
  	            // Convert
  	            var hexChars = [];
  	            for (var i = 0; i < sigBytes; i++) {
  	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  	                hexChars.push((bite >>> 4).toString(16));
  	                hexChars.push((bite & 0x0f).toString(16));
  	            }
  
  	            return hexChars.join('');
  	        },
  
  	        /**
  	         * Converts a hex string to a word array.
  	         *
  	         * @param {string} hexStr The hex string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
  	         */
  	        parse: function (hexStr) {
  	            // Shortcut
  	            var hexStrLength = hexStr.length;
  
  	            // Convert
  	            var words = [];
  	            for (var i = 0; i < hexStrLength; i += 2) {
  	                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
  	            }
  
  	            return new WordArray.init(words, hexStrLength / 2);
  	        }
  	    };
  
  	    /**
  	     * Latin1 encoding strategy.
  	     */
  	    var Latin1 = C_enc.Latin1 = {
  	        /**
  	         * Converts a word array to a Latin1 string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The Latin1 string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            // Shortcuts
  	            var words = wordArray.words;
  	            var sigBytes = wordArray.sigBytes;
  
  	            // Convert
  	            var latin1Chars = [];
  	            for (var i = 0; i < sigBytes; i++) {
  	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
  	                latin1Chars.push(String.fromCharCode(bite));
  	            }
  
  	            return latin1Chars.join('');
  	        },
  
  	        /**
  	         * Converts a Latin1 string to a word array.
  	         *
  	         * @param {string} latin1Str The Latin1 string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
  	         */
  	        parse: function (latin1Str) {
  	            // Shortcut
  	            var latin1StrLength = latin1Str.length;
  
  	            // Convert
  	            var words = [];
  	            for (var i = 0; i < latin1StrLength; i++) {
  	                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
  	            }
  
  	            return new WordArray.init(words, latin1StrLength);
  	        }
  	    };
  
  	    /**
  	     * UTF-8 encoding strategy.
  	     */
  	    var Utf8 = C_enc.Utf8 = {
  	        /**
  	         * Converts a word array to a UTF-8 string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The UTF-8 string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            try {
  	                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
  	            } catch (e) {
  	                throw new Error('Malformed UTF-8 data');
  	            }
  	        },
  
  	        /**
  	         * Converts a UTF-8 string to a word array.
  	         *
  	         * @param {string} utf8Str The UTF-8 string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
  	         */
  	        parse: function (utf8Str) {
  	            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
  	        }
  	    };
  
  	    /**
  	     * Abstract buffered block algorithm template.
  	     *
  	     * The property blockSize must be implemented in a concrete subtype.
  	     *
  	     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
  	     */
  	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
  	        /**
  	         * Resets this block algorithm's data buffer to its initial state.
  	         *
  	         * @example
  	         *
  	         *     bufferedBlockAlgorithm.reset();
  	         */
  	        reset: function () {
  	            // Initial values
  	            this._data = new WordArray.init();
  	            this._nDataBytes = 0;
  	        },
  
  	        /**
  	         * Adds new data to this block algorithm's buffer.
  	         *
  	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
  	         *
  	         * @example
  	         *
  	         *     bufferedBlockAlgorithm._append('data');
  	         *     bufferedBlockAlgorithm._append(wordArray);
  	         */
  	        _append: function (data) {
  	            // Convert string to WordArray, else assume WordArray already
  	            if (typeof data == 'string') {
  	                data = Utf8.parse(data);
  	            }
  
  	            // Append
  	            this._data.concat(data);
  	            this._nDataBytes += data.sigBytes;
  	        },
  
  	        /**
  	         * Processes available data blocks.
  	         *
  	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
  	         *
  	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
  	         *
  	         * @return {WordArray} The processed data.
  	         *
  	         * @example
  	         *
  	         *     var processedData = bufferedBlockAlgorithm._process();
  	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
  	         */
  	        _process: function (doFlush) {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  	            var dataSigBytes = data.sigBytes;
  	            var blockSize = this.blockSize;
  	            var blockSizeBytes = blockSize * 4;
  
  	            // Count blocks ready
  	            var nBlocksReady = dataSigBytes / blockSizeBytes;
  	            if (doFlush) {
  	                // Round up to include partial blocks
  	                nBlocksReady = Math.ceil(nBlocksReady);
  	            } else {
  	                // Round down to include only full blocks,
  	                // less the number of blocks that must remain in the buffer
  	                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
  	            }
  
  	            // Count words ready
  	            var nWordsReady = nBlocksReady * blockSize;
  
  	            // Count bytes ready
  	            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
  
  	            // Process blocks
  	            if (nWordsReady) {
  	                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
  	                    // Perform concrete-algorithm logic
  	                    this._doProcessBlock(dataWords, offset);
  	                }
  
  	                // Remove processed words
  	                var processedWords = dataWords.splice(0, nWordsReady);
  	                data.sigBytes -= nBytesReady;
  	            }
  
  	            // Return processed words
  	            return new WordArray.init(processedWords, nBytesReady);
  	        },
  
  	        /**
  	         * Creates a copy of this object.
  	         *
  	         * @return {Object} The clone.
  	         *
  	         * @example
  	         *
  	         *     var clone = bufferedBlockAlgorithm.clone();
  	         */
  	        clone: function () {
  	            var clone = Base.clone.call(this);
  	            clone._data = this._data.clone();
  
  	            return clone;
  	        },
  
  	        _minBufferSize: 0
  	    });
  
  	    /**
  	     * Abstract hasher template.
  	     *
  	     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
  	     */
  	    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
  	        /**
  	         * Configuration options.
  	         */
  	        cfg: Base.extend(),
  
  	        /**
  	         * Initializes a newly created hasher.
  	         *
  	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
  	         *
  	         * @example
  	         *
  	         *     var hasher = CryptoJS.algo.SHA256.create();
  	         */
  	        init: function (cfg) {
  	            // Apply config defaults
  	            this.cfg = this.cfg.extend(cfg);
  
  	            // Set initial values
  	            this.reset();
  	        },
  
  	        /**
  	         * Resets this hasher to its initial state.
  	         *
  	         * @example
  	         *
  	         *     hasher.reset();
  	         */
  	        reset: function () {
  	            // Reset data buffer
  	            BufferedBlockAlgorithm.reset.call(this);
  
  	            // Perform concrete-hasher logic
  	            this._doReset();
  	        },
  
  	        /**
  	         * Updates this hasher with a message.
  	         *
  	         * @param {WordArray|string} messageUpdate The message to append.
  	         *
  	         * @return {Hasher} This hasher.
  	         *
  	         * @example
  	         *
  	         *     hasher.update('message');
  	         *     hasher.update(wordArray);
  	         */
  	        update: function (messageUpdate) {
  	            // Append
  	            this._append(messageUpdate);
  
  	            // Update the hash
  	            this._process();
  
  	            // Chainable
  	            return this;
  	        },
  
  	        /**
  	         * Finalizes the hash computation.
  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  	         *
  	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
  	         *
  	         * @return {WordArray} The hash.
  	         *
  	         * @example
  	         *
  	         *     var hash = hasher.finalize();
  	         *     var hash = hasher.finalize('message');
  	         *     var hash = hasher.finalize(wordArray);
  	         */
  	        finalize: function (messageUpdate) {
  	            // Final message update
  	            if (messageUpdate) {
  	                this._append(messageUpdate);
  	            }
  
  	            // Perform concrete-hasher logic
  	            var hash = this._doFinalize();
  
  	            return hash;
  	        },
  
  	        blockSize: 512/32,
  
  	        /**
  	         * Creates a shortcut function to a hasher's object interface.
  	         *
  	         * @param {Hasher} hasher The hasher to create a helper for.
  	         *
  	         * @return {Function} The shortcut function.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
  	         */
  	        _createHelper: function (hasher) {
  	            return function (message, cfg) {
  	                return new hasher.init(cfg).finalize(message);
  	            };
  	        },
  
  	        /**
  	         * Creates a shortcut function to the HMAC's object interface.
  	         *
  	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
  	         *
  	         * @return {Function} The shortcut function.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
  	         */
  	        _createHmacHelper: function (hasher) {
  	            return function (message, key) {
  	                return new C_algo.HMAC.init(hasher, key).finalize(message);
  	            };
  	        }
  	    });
  
  	    /**
  	     * Algorithm namespace.
  	     */
  	    var C_algo = C.algo = {};
  
  	    return C;
  	}(Math));
  
  
  	return CryptoJS;
  
  }));
  },{}],62:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var C_enc = C.enc;
  
  	    /**
  	     * Base64 encoding strategy.
  	     */
  	    var Base64 = C_enc.Base64 = {
  	        /**
  	         * Converts a word array to a Base64 string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The Base64 string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            // Shortcuts
  	            var words = wordArray.words;
  	            var sigBytes = wordArray.sigBytes;
  	            var map = this._map;
  
  	            // Clamp excess bits
  	            wordArray.clamp();
  
  	            // Convert
  	            var base64Chars = [];
  	            for (var i = 0; i < sigBytes; i += 3) {
  	                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
  	                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
  	                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
  
  	                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
  
  	                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
  	                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
  	                }
  	            }
  
  	            // Add padding
  	            var paddingChar = map.charAt(64);
  	            if (paddingChar) {
  	                while (base64Chars.length % 4) {
  	                    base64Chars.push(paddingChar);
  	                }
  	            }
  
  	            return base64Chars.join('');
  	        },
  
  	        /**
  	         * Converts a Base64 string to a word array.
  	         *
  	         * @param {string} base64Str The Base64 string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
  	         */
  	        parse: function (base64Str) {
  	            // Shortcuts
  	            var base64StrLength = base64Str.length;
  	            var map = this._map;
  	            var reverseMap = this._reverseMap;
  
  	            if (!reverseMap) {
  	                    reverseMap = this._reverseMap = [];
  	                    for (var j = 0; j < map.length; j++) {
  	                        reverseMap[map.charCodeAt(j)] = j;
  	                    }
  	            }
  
  	            // Ignore padding
  	            var paddingChar = map.charAt(64);
  	            if (paddingChar) {
  	                var paddingIndex = base64Str.indexOf(paddingChar);
  	                if (paddingIndex !== -1) {
  	                    base64StrLength = paddingIndex;
  	                }
  	            }
  
  	            // Convert
  	            return parseLoop(base64Str, base64StrLength, reverseMap);
  
  	        },
  
  	        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  	    };
  
  	    function parseLoop(base64Str, base64StrLength, reverseMap) {
  	      var words = [];
  	      var nBytes = 0;
  	      for (var i = 0; i < base64StrLength; i++) {
  	          if (i % 4) {
  	              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
  	              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
  	              words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
  	              nBytes++;
  	          }
  	      }
  	      return WordArray.create(words, nBytes);
  	    }
  	}());
  
  
  	return CryptoJS.enc.Base64;
  
  }));
  },{"./core":61}],63:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var C_enc = C.enc;
  
  	    /**
  	     * UTF-16 BE encoding strategy.
  	     */
  	    var Utf16BE = C_enc.Utf16 = C_enc.Utf16BE = {
  	        /**
  	         * Converts a word array to a UTF-16 BE string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The UTF-16 BE string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            // Shortcuts
  	            var words = wordArray.words;
  	            var sigBytes = wordArray.sigBytes;
  
  	            // Convert
  	            var utf16Chars = [];
  	            for (var i = 0; i < sigBytes; i += 2) {
  	                var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
  	                utf16Chars.push(String.fromCharCode(codePoint));
  	            }
  
  	            return utf16Chars.join('');
  	        },
  
  	        /**
  	         * Converts a UTF-16 BE string to a word array.
  	         *
  	         * @param {string} utf16Str The UTF-16 BE string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
  	         */
  	        parse: function (utf16Str) {
  	            // Shortcut
  	            var utf16StrLength = utf16Str.length;
  
  	            // Convert
  	            var words = [];
  	            for (var i = 0; i < utf16StrLength; i++) {
  	                words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
  	            }
  
  	            return WordArray.create(words, utf16StrLength * 2);
  	        }
  	    };
  
  	    /**
  	     * UTF-16 LE encoding strategy.
  	     */
  	    C_enc.Utf16LE = {
  	        /**
  	         * Converts a word array to a UTF-16 LE string.
  	         *
  	         * @param {WordArray} wordArray The word array.
  	         *
  	         * @return {string} The UTF-16 LE string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
  	         */
  	        stringify: function (wordArray) {
  	            // Shortcuts
  	            var words = wordArray.words;
  	            var sigBytes = wordArray.sigBytes;
  
  	            // Convert
  	            var utf16Chars = [];
  	            for (var i = 0; i < sigBytes; i += 2) {
  	                var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
  	                utf16Chars.push(String.fromCharCode(codePoint));
  	            }
  
  	            return utf16Chars.join('');
  	        },
  
  	        /**
  	         * Converts a UTF-16 LE string to a word array.
  	         *
  	         * @param {string} utf16Str The UTF-16 LE string.
  	         *
  	         * @return {WordArray} The word array.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
  	         */
  	        parse: function (utf16Str) {
  	            // Shortcut
  	            var utf16StrLength = utf16Str.length;
  
  	            // Convert
  	            var words = [];
  	            for (var i = 0; i < utf16StrLength; i++) {
  	                words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
  	            }
  
  	            return WordArray.create(words, utf16StrLength * 2);
  	        }
  	    };
  
  	    function swapEndian(word) {
  	        return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
  	    }
  	}());
  
  
  	return CryptoJS.enc.Utf16;
  
  }));
  },{"./core":61}],64:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./sha1", "./hmac"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Base = C_lib.Base;
  	    var WordArray = C_lib.WordArray;
  	    var C_algo = C.algo;
  	    var MD5 = C_algo.MD5;
  
  	    /**
  	     * This key derivation function is meant to conform with EVP_BytesToKey.
  	     * www.openssl.org/docs/crypto/EVP_BytesToKey.html
  	     */
  	    var EvpKDF = C_algo.EvpKDF = Base.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
  	         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
  	         * @property {number} iterations The number of iterations to perform. Default: 1
  	         */
  	        cfg: Base.extend({
  	            keySize: 128/32,
  	            hasher: MD5,
  	            iterations: 1
  	        }),
  
  	        /**
  	         * Initializes a newly created key derivation function.
  	         *
  	         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
  	         *
  	         * @example
  	         *
  	         *     var kdf = CryptoJS.algo.EvpKDF.create();
  	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
  	         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
  	         */
  	        init: function (cfg) {
  	            this.cfg = this.cfg.extend(cfg);
  	        },
  
  	        /**
  	         * Derives a key from a password.
  	         *
  	         * @param {WordArray|string} password The password.
  	         * @param {WordArray|string} salt A salt.
  	         *
  	         * @return {WordArray} The derived key.
  	         *
  	         * @example
  	         *
  	         *     var key = kdf.compute(password, salt);
  	         */
  	        compute: function (password, salt) {
  	            // Shortcut
  	            var cfg = this.cfg;
  
  	            // Init hasher
  	            var hasher = cfg.hasher.create();
  
  	            // Initial values
  	            var derivedKey = WordArray.create();
  
  	            // Shortcuts
  	            var derivedKeyWords = derivedKey.words;
  	            var keySize = cfg.keySize;
  	            var iterations = cfg.iterations;
  
  	            // Generate key
  	            while (derivedKeyWords.length < keySize) {
  	                if (block) {
  	                    hasher.update(block);
  	                }
  	                var block = hasher.update(password).finalize(salt);
  	                hasher.reset();
  
  	                // Iterations
  	                for (var i = 1; i < iterations; i++) {
  	                    block = hasher.finalize(block);
  	                    hasher.reset();
  	                }
  
  	                derivedKey.concat(block);
  	            }
  	            derivedKey.sigBytes = keySize * 4;
  
  	            return derivedKey;
  	        }
  	    });
  
  	    /**
  	     * Derives a key from a password.
  	     *
  	     * @param {WordArray|string} password The password.
  	     * @param {WordArray|string} salt A salt.
  	     * @param {Object} cfg (Optional) The configuration options to use for this computation.
  	     *
  	     * @return {WordArray} The derived key.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var key = CryptoJS.EvpKDF(password, salt);
  	     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
  	     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
  	     */
  	    C.EvpKDF = function (password, salt, cfg) {
  	        return EvpKDF.create(cfg).compute(password, salt);
  	    };
  	}());
  
  
  	return CryptoJS.EvpKDF;
  
  }));
  },{"./core":61,"./hmac":66,"./sha1":85}],65:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function (undefined) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var CipherParams = C_lib.CipherParams;
  	    var C_enc = C.enc;
  	    var Hex = C_enc.Hex;
  	    var C_format = C.format;
  
  	    var HexFormatter = C_format.Hex = {
  	        /**
  	         * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
  	         *
  	         * @param {CipherParams} cipherParams The cipher params object.
  	         *
  	         * @return {string} The hexadecimally encoded string.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
  	         */
  	        stringify: function (cipherParams) {
  	            return cipherParams.ciphertext.toString(Hex);
  	        },
  
  	        /**
  	         * Converts a hexadecimally encoded ciphertext string to a cipher params object.
  	         *
  	         * @param {string} input The hexadecimally encoded string.
  	         *
  	         * @return {CipherParams} The cipher params object.
  	         *
  	         * @static
  	         *
  	         * @example
  	         *
  	         *     var cipherParams = CryptoJS.format.Hex.parse(hexString);
  	         */
  	        parse: function (input) {
  	            var ciphertext = Hex.parse(input);
  	            return CipherParams.create({ ciphertext: ciphertext });
  	        }
  	    };
  	}());
  
  
  	return CryptoJS.format.Hex;
  
  }));
  },{"./cipher-core":60,"./core":61}],66:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Base = C_lib.Base;
  	    var C_enc = C.enc;
  	    var Utf8 = C_enc.Utf8;
  	    var C_algo = C.algo;
  
  	    /**
  	     * HMAC algorithm.
  	     */
  	    var HMAC = C_algo.HMAC = Base.extend({
  	        /**
  	         * Initializes a newly created HMAC.
  	         *
  	         * @param {Hasher} hasher The hash algorithm to use.
  	         * @param {WordArray|string} key The secret key.
  	         *
  	         * @example
  	         *
  	         *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
  	         */
  	        init: function (hasher, key) {
  	            // Init hasher
  	            hasher = this._hasher = new hasher.init();
  
  	            // Convert string to WordArray, else assume WordArray already
  	            if (typeof key == 'string') {
  	                key = Utf8.parse(key);
  	            }
  
  	            // Shortcuts
  	            var hasherBlockSize = hasher.blockSize;
  	            var hasherBlockSizeBytes = hasherBlockSize * 4;
  
  	            // Allow arbitrary length keys
  	            if (key.sigBytes > hasherBlockSizeBytes) {
  	                key = hasher.finalize(key);
  	            }
  
  	            // Clamp excess bits
  	            key.clamp();
  
  	            // Clone key for inner and outer pads
  	            var oKey = this._oKey = key.clone();
  	            var iKey = this._iKey = key.clone();
  
  	            // Shortcuts
  	            var oKeyWords = oKey.words;
  	            var iKeyWords = iKey.words;
  
  	            // XOR keys with pad constants
  	            for (var i = 0; i < hasherBlockSize; i++) {
  	                oKeyWords[i] ^= 0x5c5c5c5c;
  	                iKeyWords[i] ^= 0x36363636;
  	            }
  	            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
  
  	            // Set initial values
  	            this.reset();
  	        },
  
  	        /**
  	         * Resets this HMAC to its initial state.
  	         *
  	         * @example
  	         *
  	         *     hmacHasher.reset();
  	         */
  	        reset: function () {
  	            // Shortcut
  	            var hasher = this._hasher;
  
  	            // Reset
  	            hasher.reset();
  	            hasher.update(this._iKey);
  	        },
  
  	        /**
  	         * Updates this HMAC with a message.
  	         *
  	         * @param {WordArray|string} messageUpdate The message to append.
  	         *
  	         * @return {HMAC} This HMAC instance.
  	         *
  	         * @example
  	         *
  	         *     hmacHasher.update('message');
  	         *     hmacHasher.update(wordArray);
  	         */
  	        update: function (messageUpdate) {
  	            this._hasher.update(messageUpdate);
  
  	            // Chainable
  	            return this;
  	        },
  
  	        /**
  	         * Finalizes the HMAC computation.
  	         * Note that the finalize operation is effectively a destructive, read-once operation.
  	         *
  	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
  	         *
  	         * @return {WordArray} The HMAC.
  	         *
  	         * @example
  	         *
  	         *     var hmac = hmacHasher.finalize();
  	         *     var hmac = hmacHasher.finalize('message');
  	         *     var hmac = hmacHasher.finalize(wordArray);
  	         */
  	        finalize: function (messageUpdate) {
  	            // Shortcut
  	            var hasher = this._hasher;
  
  	            // Compute HMAC
  	            var innerHash = hasher.finalize(messageUpdate);
  	            hasher.reset();
  	            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
  
  	            return hmac;
  	        }
  	    });
  	}());
  
  
  }));
  },{"./core":61}],67:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./x64-core"), require("./lib-typedarrays"), require("./enc-utf16"), require("./enc-base64"), require("./md5"), require("./sha1"), require("./sha256"), require("./sha224"), require("./sha512"), require("./sha384"), require("./sha3"), require("./ripemd160"), require("./hmac"), require("./pbkdf2"), require("./evpkdf"), require("./cipher-core"), require("./mode-cfb"), require("./mode-ctr"), require("./mode-ctr-gladman"), require("./mode-ofb"), require("./mode-ecb"), require("./pad-ansix923"), require("./pad-iso10126"), require("./pad-iso97971"), require("./pad-zeropadding"), require("./pad-nopadding"), require("./format-hex"), require("./aes"), require("./tripledes"), require("./rc4"), require("./rabbit"), require("./rabbit-legacy"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./x64-core", "./lib-typedarrays", "./enc-utf16", "./enc-base64", "./md5", "./sha1", "./sha256", "./sha224", "./sha512", "./sha384", "./sha3", "./ripemd160", "./hmac", "./pbkdf2", "./evpkdf", "./cipher-core", "./mode-cfb", "./mode-ctr", "./mode-ctr-gladman", "./mode-ofb", "./mode-ecb", "./pad-ansix923", "./pad-iso10126", "./pad-iso97971", "./pad-zeropadding", "./pad-nopadding", "./format-hex", "./aes", "./tripledes", "./rc4", "./rabbit", "./rabbit-legacy"], factory);
  	}
  	else {
  		// Global (browser)
  		root.CryptoJS = factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	return CryptoJS;
  
  }));
  },{"./aes":59,"./cipher-core":60,"./core":61,"./enc-base64":62,"./enc-utf16":63,"./evpkdf":64,"./format-hex":65,"./hmac":66,"./lib-typedarrays":68,"./md5":69,"./mode-cfb":70,"./mode-ctr":72,"./mode-ctr-gladman":71,"./mode-ecb":73,"./mode-ofb":74,"./pad-ansix923":75,"./pad-iso10126":76,"./pad-iso97971":77,"./pad-nopadding":78,"./pad-zeropadding":79,"./pbkdf2":80,"./rabbit":82,"./rabbit-legacy":81,"./rc4":83,"./ripemd160":84,"./sha1":85,"./sha224":86,"./sha256":87,"./sha3":88,"./sha384":89,"./sha512":90,"./tripledes":91,"./x64-core":92}],68:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Check if typed arrays are supported
  	    if (typeof ArrayBuffer != 'function') {
  	        return;
  	    }
  
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  
  	    // Reference original init
  	    var superInit = WordArray.init;
  
  	    // Augment WordArray.init to handle typed arrays
  	    var subInit = WordArray.init = function (typedArray) {
  	        // Convert buffers to uint8
  	        if (typedArray instanceof ArrayBuffer) {
  	            typedArray = new Uint8Array(typedArray);
  	        }
  
  	        // Convert other array views to uint8
  	        if (
  	            typedArray instanceof Int8Array ||
  	            (typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray) ||
  	            typedArray instanceof Int16Array ||
  	            typedArray instanceof Uint16Array ||
  	            typedArray instanceof Int32Array ||
  	            typedArray instanceof Uint32Array ||
  	            typedArray instanceof Float32Array ||
  	            typedArray instanceof Float64Array
  	        ) {
  	            typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
  	        }
  
  	        // Handle Uint8Array
  	        if (typedArray instanceof Uint8Array) {
  	            // Shortcut
  	            var typedArrayByteLength = typedArray.byteLength;
  
  	            // Extract bytes
  	            var words = [];
  	            for (var i = 0; i < typedArrayByteLength; i++) {
  	                words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8);
  	            }
  
  	            // Initialize this word array
  	            superInit.call(this, words, typedArrayByteLength);
  	        } else {
  	            // Else call normal init
  	            superInit.apply(this, arguments);
  	        }
  	    };
  
  	    subInit.prototype = WordArray;
  	}());
  
  
  	return CryptoJS.lib.WordArray;
  
  }));
  },{"./core":61}],69:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function (Math) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var Hasher = C_lib.Hasher;
  	    var C_algo = C.algo;
  
  	    // Constants table
  	    var T = [];
  
  	    // Compute constants
  	    (function () {
  	        for (var i = 0; i < 64; i++) {
  	            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
  	        }
  	    }());
  
  	    /**
  	     * MD5 hash algorithm.
  	     */
  	    var MD5 = C_algo.MD5 = Hasher.extend({
  	        _doReset: function () {
  	            this._hash = new WordArray.init([
  	                0x67452301, 0xefcdab89,
  	                0x98badcfe, 0x10325476
  	            ]);
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Swap endian
  	            for (var i = 0; i < 16; i++) {
  	                // Shortcuts
  	                var offset_i = offset + i;
  	                var M_offset_i = M[offset_i];
  
  	                M[offset_i] = (
  	                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
  	                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
  	                );
  	            }
  
  	            // Shortcuts
  	            var H = this._hash.words;
  
  	            var M_offset_0  = M[offset + 0];
  	            var M_offset_1  = M[offset + 1];
  	            var M_offset_2  = M[offset + 2];
  	            var M_offset_3  = M[offset + 3];
  	            var M_offset_4  = M[offset + 4];
  	            var M_offset_5  = M[offset + 5];
  	            var M_offset_6  = M[offset + 6];
  	            var M_offset_7  = M[offset + 7];
  	            var M_offset_8  = M[offset + 8];
  	            var M_offset_9  = M[offset + 9];
  	            var M_offset_10 = M[offset + 10];
  	            var M_offset_11 = M[offset + 11];
  	            var M_offset_12 = M[offset + 12];
  	            var M_offset_13 = M[offset + 13];
  	            var M_offset_14 = M[offset + 14];
  	            var M_offset_15 = M[offset + 15];
  
  	            // Working varialbes
  	            var a = H[0];
  	            var b = H[1];
  	            var c = H[2];
  	            var d = H[3];
  
  	            // Computation
  	            a = FF(a, b, c, d, M_offset_0,  7,  T[0]);
  	            d = FF(d, a, b, c, M_offset_1,  12, T[1]);
  	            c = FF(c, d, a, b, M_offset_2,  17, T[2]);
  	            b = FF(b, c, d, a, M_offset_3,  22, T[3]);
  	            a = FF(a, b, c, d, M_offset_4,  7,  T[4]);
  	            d = FF(d, a, b, c, M_offset_5,  12, T[5]);
  	            c = FF(c, d, a, b, M_offset_6,  17, T[6]);
  	            b = FF(b, c, d, a, M_offset_7,  22, T[7]);
  	            a = FF(a, b, c, d, M_offset_8,  7,  T[8]);
  	            d = FF(d, a, b, c, M_offset_9,  12, T[9]);
  	            c = FF(c, d, a, b, M_offset_10, 17, T[10]);
  	            b = FF(b, c, d, a, M_offset_11, 22, T[11]);
  	            a = FF(a, b, c, d, M_offset_12, 7,  T[12]);
  	            d = FF(d, a, b, c, M_offset_13, 12, T[13]);
  	            c = FF(c, d, a, b, M_offset_14, 17, T[14]);
  	            b = FF(b, c, d, a, M_offset_15, 22, T[15]);
  
  	            a = GG(a, b, c, d, M_offset_1,  5,  T[16]);
  	            d = GG(d, a, b, c, M_offset_6,  9,  T[17]);
  	            c = GG(c, d, a, b, M_offset_11, 14, T[18]);
  	            b = GG(b, c, d, a, M_offset_0,  20, T[19]);
  	            a = GG(a, b, c, d, M_offset_5,  5,  T[20]);
  	            d = GG(d, a, b, c, M_offset_10, 9,  T[21]);
  	            c = GG(c, d, a, b, M_offset_15, 14, T[22]);
  	            b = GG(b, c, d, a, M_offset_4,  20, T[23]);
  	            a = GG(a, b, c, d, M_offset_9,  5,  T[24]);
  	            d = GG(d, a, b, c, M_offset_14, 9,  T[25]);
  	            c = GG(c, d, a, b, M_offset_3,  14, T[26]);
  	            b = GG(b, c, d, a, M_offset_8,  20, T[27]);
  	            a = GG(a, b, c, d, M_offset_13, 5,  T[28]);
  	            d = GG(d, a, b, c, M_offset_2,  9,  T[29]);
  	            c = GG(c, d, a, b, M_offset_7,  14, T[30]);
  	            b = GG(b, c, d, a, M_offset_12, 20, T[31]);
  
  	            a = HH(a, b, c, d, M_offset_5,  4,  T[32]);
  	            d = HH(d, a, b, c, M_offset_8,  11, T[33]);
  	            c = HH(c, d, a, b, M_offset_11, 16, T[34]);
  	            b = HH(b, c, d, a, M_offset_14, 23, T[35]);
  	            a = HH(a, b, c, d, M_offset_1,  4,  T[36]);
  	            d = HH(d, a, b, c, M_offset_4,  11, T[37]);
  	            c = HH(c, d, a, b, M_offset_7,  16, T[38]);
  	            b = HH(b, c, d, a, M_offset_10, 23, T[39]);
  	            a = HH(a, b, c, d, M_offset_13, 4,  T[40]);
  	            d = HH(d, a, b, c, M_offset_0,  11, T[41]);
  	            c = HH(c, d, a, b, M_offset_3,  16, T[42]);
  	            b = HH(b, c, d, a, M_offset_6,  23, T[43]);
  	            a = HH(a, b, c, d, M_offset_9,  4,  T[44]);
  	            d = HH(d, a, b, c, M_offset_12, 11, T[45]);
  	            c = HH(c, d, a, b, M_offset_15, 16, T[46]);
  	            b = HH(b, c, d, a, M_offset_2,  23, T[47]);
  
  	            a = II(a, b, c, d, M_offset_0,  6,  T[48]);
  	            d = II(d, a, b, c, M_offset_7,  10, T[49]);
  	            c = II(c, d, a, b, M_offset_14, 15, T[50]);
  	            b = II(b, c, d, a, M_offset_5,  21, T[51]);
  	            a = II(a, b, c, d, M_offset_12, 6,  T[52]);
  	            d = II(d, a, b, c, M_offset_3,  10, T[53]);
  	            c = II(c, d, a, b, M_offset_10, 15, T[54]);
  	            b = II(b, c, d, a, M_offset_1,  21, T[55]);
  	            a = II(a, b, c, d, M_offset_8,  6,  T[56]);
  	            d = II(d, a, b, c, M_offset_15, 10, T[57]);
  	            c = II(c, d, a, b, M_offset_6,  15, T[58]);
  	            b = II(b, c, d, a, M_offset_13, 21, T[59]);
  	            a = II(a, b, c, d, M_offset_4,  6,  T[60]);
  	            d = II(d, a, b, c, M_offset_11, 10, T[61]);
  	            c = II(c, d, a, b, M_offset_2,  15, T[62]);
  	            b = II(b, c, d, a, M_offset_9,  21, T[63]);
  
  	            // Intermediate hash value
  	            H[0] = (H[0] + a) | 0;
  	            H[1] = (H[1] + b) | 0;
  	            H[2] = (H[2] + c) | 0;
  	            H[3] = (H[3] + d) | 0;
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  
  	            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
  	            var nBitsTotalL = nBitsTotal;
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
  	                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
  	                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
  	            );
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
  	                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
  	                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
  	            );
  
  	            data.sigBytes = (dataWords.length + 1) * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Shortcuts
  	            var hash = this._hash;
  	            var H = hash.words;
  
  	            // Swap endian
  	            for (var i = 0; i < 4; i++) {
  	                // Shortcut
  	                var H_i = H[i];
  
  	                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
  	                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
  	            }
  
  	            // Return final computed hash
  	            return hash;
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  	            clone._hash = this._hash.clone();
  
  	            return clone;
  	        }
  	    });
  
  	    function FF(a, b, c, d, x, s, t) {
  	        var n = a + ((b & c) | (~b & d)) + x + t;
  	        return ((n << s) | (n >>> (32 - s))) + b;
  	    }
  
  	    function GG(a, b, c, d, x, s, t) {
  	        var n = a + ((b & d) | (c & ~d)) + x + t;
  	        return ((n << s) | (n >>> (32 - s))) + b;
  	    }
  
  	    function HH(a, b, c, d, x, s, t) {
  	        var n = a + (b ^ c ^ d) + x + t;
  	        return ((n << s) | (n >>> (32 - s))) + b;
  	    }
  
  	    function II(a, b, c, d, x, s, t) {
  	        var n = a + (c ^ (b | ~d)) + x + t;
  	        return ((n << s) | (n >>> (32 - s))) + b;
  	    }
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.MD5('message');
  	     *     var hash = CryptoJS.MD5(wordArray);
  	     */
  	    C.MD5 = Hasher._createHelper(MD5);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacMD5(message, key);
  	     */
  	    C.HmacMD5 = Hasher._createHmacHelper(MD5);
  	}(Math));
  
  
  	return CryptoJS.MD5;
  
  }));
  },{"./core":61}],70:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Cipher Feedback block mode.
  	 */
  	CryptoJS.mode.CFB = (function () {
  	    var CFB = CryptoJS.lib.BlockCipherMode.extend();
  
  	    CFB.Encryptor = CFB.extend({
  	        processBlock: function (words, offset) {
  	            // Shortcuts
  	            var cipher = this._cipher;
  	            var blockSize = cipher.blockSize;
  
  	            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
  
  	            // Remember this block to use with next block
  	            this._prevBlock = words.slice(offset, offset + blockSize);
  	        }
  	    });
  
  	    CFB.Decryptor = CFB.extend({
  	        processBlock: function (words, offset) {
  	            // Shortcuts
  	            var cipher = this._cipher;
  	            var blockSize = cipher.blockSize;
  
  	            // Remember this block to use with next block
  	            var thisBlock = words.slice(offset, offset + blockSize);
  
  	            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
  
  	            // This block becomes the previous block
  	            this._prevBlock = thisBlock;
  	        }
  	    });
  
  	    function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
  	        // Shortcut
  	        var iv = this._iv;
  
  	        // Generate keystream
  	        if (iv) {
  	            var keystream = iv.slice(0);
  
  	            // Remove IV for subsequent blocks
  	            this._iv = undefined;
  	        } else {
  	            var keystream = this._prevBlock;
  	        }
  	        cipher.encryptBlock(keystream, 0);
  
  	        // Encrypt
  	        for (var i = 0; i < blockSize; i++) {
  	            words[offset + i] ^= keystream[i];
  	        }
  	    }
  
  	    return CFB;
  	}());
  
  
  	return CryptoJS.mode.CFB;
  
  }));
  },{"./cipher-core":60,"./core":61}],71:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/** @preserve
  	 * Counter block mode compatible with  Dr Brian Gladman fileenc.c
  	 * derived from CryptoJS.mode.CTR
  	 * Jan Hruby jhruby.web@gmail.com
  	 */
  	CryptoJS.mode.CTRGladman = (function () {
  	    var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
  
  		function incWord(word)
  		{
  			if (((word >> 24) & 0xff) === 0xff) { //overflow
  			var b1 = (word >> 16)&0xff;
  			var b2 = (word >> 8)&0xff;
  			var b3 = word & 0xff;
  
  			if (b1 === 0xff) // overflow b1
  			{
  			b1 = 0;
  			if (b2 === 0xff)
  			{
  				b2 = 0;
  				if (b3 === 0xff)
  				{
  					b3 = 0;
  				}
  				else
  				{
  					++b3;
  				}
  			}
  			else
  			{
  				++b2;
  			}
  			}
  			else
  			{
  			++b1;
  			}
  
  			word = 0;
  			word += (b1 << 16);
  			word += (b2 << 8);
  			word += b3;
  			}
  			else
  			{
  			word += (0x01 << 24);
  			}
  			return word;
  		}
  
  		function incCounter(counter)
  		{
  			if ((counter[0] = incWord(counter[0])) === 0)
  			{
  				// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
  				counter[1] = incWord(counter[1]);
  			}
  			return counter;
  		}
  
  	    var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
  	        processBlock: function (words, offset) {
  	            // Shortcuts
  	            var cipher = this._cipher
  	            var blockSize = cipher.blockSize;
  	            var iv = this._iv;
  	            var counter = this._counter;
  
  	            // Generate keystream
  	            if (iv) {
  	                counter = this._counter = iv.slice(0);
  
  	                // Remove IV for subsequent blocks
  	                this._iv = undefined;
  	            }
  
  				incCounter(counter);
  
  				var keystream = counter.slice(0);
  	            cipher.encryptBlock(keystream, 0);
  
  	            // Encrypt
  	            for (var i = 0; i < blockSize; i++) {
  	                words[offset + i] ^= keystream[i];
  	            }
  	        }
  	    });
  
  	    CTRGladman.Decryptor = Encryptor;
  
  	    return CTRGladman;
  	}());
  
  
  
  
  	return CryptoJS.mode.CTRGladman;
  
  }));
  },{"./cipher-core":60,"./core":61}],72:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Counter block mode.
  	 */
  	CryptoJS.mode.CTR = (function () {
  	    var CTR = CryptoJS.lib.BlockCipherMode.extend();
  
  	    var Encryptor = CTR.Encryptor = CTR.extend({
  	        processBlock: function (words, offset) {
  	            // Shortcuts
  	            var cipher = this._cipher
  	            var blockSize = cipher.blockSize;
  	            var iv = this._iv;
  	            var counter = this._counter;
  
  	            // Generate keystream
  	            if (iv) {
  	                counter = this._counter = iv.slice(0);
  
  	                // Remove IV for subsequent blocks
  	                this._iv = undefined;
  	            }
  	            var keystream = counter.slice(0);
  	            cipher.encryptBlock(keystream, 0);
  
  	            // Increment counter
  	            counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0
  
  	            // Encrypt
  	            for (var i = 0; i < blockSize; i++) {
  	                words[offset + i] ^= keystream[i];
  	            }
  	        }
  	    });
  
  	    CTR.Decryptor = Encryptor;
  
  	    return CTR;
  	}());
  
  
  	return CryptoJS.mode.CTR;
  
  }));
  },{"./cipher-core":60,"./core":61}],73:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Electronic Codebook block mode.
  	 */
  	CryptoJS.mode.ECB = (function () {
  	    var ECB = CryptoJS.lib.BlockCipherMode.extend();
  
  	    ECB.Encryptor = ECB.extend({
  	        processBlock: function (words, offset) {
  	            this._cipher.encryptBlock(words, offset);
  	        }
  	    });
  
  	    ECB.Decryptor = ECB.extend({
  	        processBlock: function (words, offset) {
  	            this._cipher.decryptBlock(words, offset);
  	        }
  	    });
  
  	    return ECB;
  	}());
  
  
  	return CryptoJS.mode.ECB;
  
  }));
  },{"./cipher-core":60,"./core":61}],74:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Output Feedback block mode.
  	 */
  	CryptoJS.mode.OFB = (function () {
  	    var OFB = CryptoJS.lib.BlockCipherMode.extend();
  
  	    var Encryptor = OFB.Encryptor = OFB.extend({
  	        processBlock: function (words, offset) {
  	            // Shortcuts
  	            var cipher = this._cipher
  	            var blockSize = cipher.blockSize;
  	            var iv = this._iv;
  	            var keystream = this._keystream;
  
  	            // Generate keystream
  	            if (iv) {
  	                keystream = this._keystream = iv.slice(0);
  
  	                // Remove IV for subsequent blocks
  	                this._iv = undefined;
  	            }
  	            cipher.encryptBlock(keystream, 0);
  
  	            // Encrypt
  	            for (var i = 0; i < blockSize; i++) {
  	                words[offset + i] ^= keystream[i];
  	            }
  	        }
  	    });
  
  	    OFB.Decryptor = Encryptor;
  
  	    return OFB;
  	}());
  
  
  	return CryptoJS.mode.OFB;
  
  }));
  },{"./cipher-core":60,"./core":61}],75:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * ANSI X.923 padding strategy.
  	 */
  	CryptoJS.pad.AnsiX923 = {
  	    pad: function (data, blockSize) {
  	        // Shortcuts
  	        var dataSigBytes = data.sigBytes;
  	        var blockSizeBytes = blockSize * 4;
  
  	        // Count padding bytes
  	        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
  
  	        // Compute last byte position
  	        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
  
  	        // Pad
  	        data.clamp();
  	        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
  	        data.sigBytes += nPaddingBytes;
  	    },
  
  	    unpad: function (data) {
  	        // Get number of padding bytes from last byte
  	        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
  
  	        // Remove padding
  	        data.sigBytes -= nPaddingBytes;
  	    }
  	};
  
  
  	return CryptoJS.pad.Ansix923;
  
  }));
  },{"./cipher-core":60,"./core":61}],76:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * ISO 10126 padding strategy.
  	 */
  	CryptoJS.pad.Iso10126 = {
  	    pad: function (data, blockSize) {
  	        // Shortcut
  	        var blockSizeBytes = blockSize * 4;
  
  	        // Count padding bytes
  	        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
  
  	        // Pad
  	        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
  	             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
  	    },
  
  	    unpad: function (data) {
  	        // Get number of padding bytes from last byte
  	        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
  
  	        // Remove padding
  	        data.sigBytes -= nPaddingBytes;
  	    }
  	};
  
  
  	return CryptoJS.pad.Iso10126;
  
  }));
  },{"./cipher-core":60,"./core":61}],77:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * ISO/IEC 9797-1 Padding Method 2.
  	 */
  	CryptoJS.pad.Iso97971 = {
  	    pad: function (data, blockSize) {
  	        // Add 0x80 byte
  	        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
  
  	        // Zero pad the rest
  	        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
  	    },
  
  	    unpad: function (data) {
  	        // Remove zero padding
  	        CryptoJS.pad.ZeroPadding.unpad(data);
  
  	        // Remove one more byte -- the 0x80 byte
  	        data.sigBytes--;
  	    }
  	};
  
  
  	return CryptoJS.pad.Iso97971;
  
  }));
  },{"./cipher-core":60,"./core":61}],78:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * A noop padding strategy.
  	 */
  	CryptoJS.pad.NoPadding = {
  	    pad: function () {
  	    },
  
  	    unpad: function () {
  	    }
  	};
  
  
  	return CryptoJS.pad.NoPadding;
  
  }));
  },{"./cipher-core":60,"./core":61}],79:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/**
  	 * Zero padding strategy.
  	 */
  	CryptoJS.pad.ZeroPadding = {
  	    pad: function (data, blockSize) {
  	        // Shortcut
  	        var blockSizeBytes = blockSize * 4;
  
  	        // Pad
  	        data.clamp();
  	        data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
  	    },
  
  	    unpad: function (data) {
  	        // Shortcut
  	        var dataWords = data.words;
  
  	        // Unpad
  	        var i = data.sigBytes - 1;
  	        while (!((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
  	            i--;
  	        }
  	        data.sigBytes = i + 1;
  	    }
  	};
  
  
  	return CryptoJS.pad.ZeroPadding;
  
  }));
  },{"./cipher-core":60,"./core":61}],80:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./sha1"), require("./hmac"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./sha1", "./hmac"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Base = C_lib.Base;
  	    var WordArray = C_lib.WordArray;
  	    var C_algo = C.algo;
  	    var SHA1 = C_algo.SHA1;
  	    var HMAC = C_algo.HMAC;
  
  	    /**
  	     * Password-Based Key Derivation Function 2 algorithm.
  	     */
  	    var PBKDF2 = C_algo.PBKDF2 = Base.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
  	         * @property {Hasher} hasher The hasher to use. Default: SHA1
  	         * @property {number} iterations The number of iterations to perform. Default: 1
  	         */
  	        cfg: Base.extend({
  	            keySize: 128/32,
  	            hasher: SHA1,
  	            iterations: 1
  	        }),
  
  	        /**
  	         * Initializes a newly created key derivation function.
  	         *
  	         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
  	         *
  	         * @example
  	         *
  	         *     var kdf = CryptoJS.algo.PBKDF2.create();
  	         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
  	         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
  	         */
  	        init: function (cfg) {
  	            this.cfg = this.cfg.extend(cfg);
  	        },
  
  	        /**
  	         * Computes the Password-Based Key Derivation Function 2.
  	         *
  	         * @param {WordArray|string} password The password.
  	         * @param {WordArray|string} salt A salt.
  	         *
  	         * @return {WordArray} The derived key.
  	         *
  	         * @example
  	         *
  	         *     var key = kdf.compute(password, salt);
  	         */
  	        compute: function (password, salt) {
  	            // Shortcut
  	            var cfg = this.cfg;
  
  	            // Init HMAC
  	            var hmac = HMAC.create(cfg.hasher, password);
  
  	            // Initial values
  	            var derivedKey = WordArray.create();
  	            var blockIndex = WordArray.create([0x00000001]);
  
  	            // Shortcuts
  	            var derivedKeyWords = derivedKey.words;
  	            var blockIndexWords = blockIndex.words;
  	            var keySize = cfg.keySize;
  	            var iterations = cfg.iterations;
  
  	            // Generate key
  	            while (derivedKeyWords.length < keySize) {
  	                var block = hmac.update(salt).finalize(blockIndex);
  	                hmac.reset();
  
  	                // Shortcuts
  	                var blockWords = block.words;
  	                var blockWordsLength = blockWords.length;
  
  	                // Iterations
  	                var intermediate = block;
  	                for (var i = 1; i < iterations; i++) {
  	                    intermediate = hmac.finalize(intermediate);
  	                    hmac.reset();
  
  	                    // Shortcut
  	                    var intermediateWords = intermediate.words;
  
  	                    // XOR intermediate with block
  	                    for (var j = 0; j < blockWordsLength; j++) {
  	                        blockWords[j] ^= intermediateWords[j];
  	                    }
  	                }
  
  	                derivedKey.concat(block);
  	                blockIndexWords[0]++;
  	            }
  	            derivedKey.sigBytes = keySize * 4;
  
  	            return derivedKey;
  	        }
  	    });
  
  	    /**
  	     * Computes the Password-Based Key Derivation Function 2.
  	     *
  	     * @param {WordArray|string} password The password.
  	     * @param {WordArray|string} salt A salt.
  	     * @param {Object} cfg (Optional) The configuration options to use for this computation.
  	     *
  	     * @return {WordArray} The derived key.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var key = CryptoJS.PBKDF2(password, salt);
  	     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
  	     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
  	     */
  	    C.PBKDF2 = function (password, salt, cfg) {
  	        return PBKDF2.create(cfg).compute(password, salt);
  	    };
  	}());
  
  
  	return CryptoJS.PBKDF2;
  
  }));
  },{"./core":61,"./hmac":66,"./sha1":85}],81:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var StreamCipher = C_lib.StreamCipher;
  	    var C_algo = C.algo;
  
  	    // Reusable objects
  	    var S  = [];
  	    var C_ = [];
  	    var G  = [];
  
  	    /**
  	     * Rabbit stream cipher algorithm.
  	     *
  	     * This is a legacy version that neglected to convert the key to little-endian.
  	     * This error doesn't affect the cipher's security,
  	     * but it does affect its compatibility with other implementations.
  	     */
  	    var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
  	        _doReset: function () {
  	            // Shortcuts
  	            var K = this._key.words;
  	            var iv = this.cfg.iv;
  
  	            // Generate initial state values
  	            var X = this._X = [
  	                K[0], (K[3] << 16) | (K[2] >>> 16),
  	                K[1], (K[0] << 16) | (K[3] >>> 16),
  	                K[2], (K[1] << 16) | (K[0] >>> 16),
  	                K[3], (K[2] << 16) | (K[1] >>> 16)
  	            ];
  
  	            // Generate initial counter values
  	            var C = this._C = [
  	                (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
  	                (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
  	                (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
  	                (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
  	            ];
  
  	            // Carry bit
  	            this._b = 0;
  
  	            // Iterate the system four times
  	            for (var i = 0; i < 4; i++) {
  	                nextState.call(this);
  	            }
  
  	            // Modify the counters
  	            for (var i = 0; i < 8; i++) {
  	                C[i] ^= X[(i + 4) & 7];
  	            }
  
  	            // IV setup
  	            if (iv) {
  	                // Shortcuts
  	                var IV = iv.words;
  	                var IV_0 = IV[0];
  	                var IV_1 = IV[1];
  
  	                // Generate four subvectors
  	                var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
  	                var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
  	                var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
  	                var i3 = (i2 << 16)  | (i0 & 0x0000ffff);
  
  	                // Modify counter values
  	                C[0] ^= i0;
  	                C[1] ^= i1;
  	                C[2] ^= i2;
  	                C[3] ^= i3;
  	                C[4] ^= i0;
  	                C[5] ^= i1;
  	                C[6] ^= i2;
  	                C[7] ^= i3;
  
  	                // Iterate the system four times
  	                for (var i = 0; i < 4; i++) {
  	                    nextState.call(this);
  	                }
  	            }
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcut
  	            var X = this._X;
  
  	            // Iterate the system
  	            nextState.call(this);
  
  	            // Generate four keystream words
  	            S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
  	            S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
  	            S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
  	            S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
  
  	            for (var i = 0; i < 4; i++) {
  	                // Swap endian
  	                S[i] = (((S[i] << 8)  | (S[i] >>> 24)) & 0x00ff00ff) |
  	                       (((S[i] << 24) | (S[i] >>> 8))  & 0xff00ff00);
  
  	                // Encrypt
  	                M[offset + i] ^= S[i];
  	            }
  	        },
  
  	        blockSize: 128/32,
  
  	        ivSize: 64/32
  	    });
  
  	    function nextState() {
  	        // Shortcuts
  	        var X = this._X;
  	        var C = this._C;
  
  	        // Save old counter values
  	        for (var i = 0; i < 8; i++) {
  	            C_[i] = C[i];
  	        }
  
  	        // Calculate new counter values
  	        C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
  	        C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
  	        C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
  	        C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
  	        C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
  	        C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
  	        C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
  	        C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
  	        this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
  
  	        // Calculate the g-values
  	        for (var i = 0; i < 8; i++) {
  	            var gx = X[i] + C[i];
  
  	            // Construct high and low argument for squaring
  	            var ga = gx & 0xffff;
  	            var gb = gx >>> 16;
  
  	            // Calculate high and low result of squaring
  	            var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
  	            var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
  
  	            // High XOR low
  	            G[i] = gh ^ gl;
  	        }
  
  	        // Calculate new state values
  	        X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
  	        X[1] = (G[1] + ((G[0] << 8)  | (G[0] >>> 24)) + G[7]) | 0;
  	        X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
  	        X[3] = (G[3] + ((G[2] << 8)  | (G[2] >>> 24)) + G[1]) | 0;
  	        X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
  	        X[5] = (G[5] + ((G[4] << 8)  | (G[4] >>> 24)) + G[3]) | 0;
  	        X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
  	        X[7] = (G[7] + ((G[6] << 8)  | (G[6] >>> 24)) + G[5]) | 0;
  	    }
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.RabbitLegacy.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.RabbitLegacy.decrypt(ciphertext, key, cfg);
  	     */
  	    C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
  	}());
  
  
  	return CryptoJS.RabbitLegacy;
  
  }));
  },{"./cipher-core":60,"./core":61,"./enc-base64":62,"./evpkdf":64,"./md5":69}],82:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var StreamCipher = C_lib.StreamCipher;
  	    var C_algo = C.algo;
  
  	    // Reusable objects
  	    var S  = [];
  	    var C_ = [];
  	    var G  = [];
  
  	    /**
  	     * Rabbit stream cipher algorithm
  	     */
  	    var Rabbit = C_algo.Rabbit = StreamCipher.extend({
  	        _doReset: function () {
  	            // Shortcuts
  	            var K = this._key.words;
  	            var iv = this.cfg.iv;
  
  	            // Swap endian
  	            for (var i = 0; i < 4; i++) {
  	                K[i] = (((K[i] << 8)  | (K[i] >>> 24)) & 0x00ff00ff) |
  	                       (((K[i] << 24) | (K[i] >>> 8))  & 0xff00ff00);
  	            }
  
  	            // Generate initial state values
  	            var X = this._X = [
  	                K[0], (K[3] << 16) | (K[2] >>> 16),
  	                K[1], (K[0] << 16) | (K[3] >>> 16),
  	                K[2], (K[1] << 16) | (K[0] >>> 16),
  	                K[3], (K[2] << 16) | (K[1] >>> 16)
  	            ];
  
  	            // Generate initial counter values
  	            var C = this._C = [
  	                (K[2] << 16) | (K[2] >>> 16), (K[0] & 0xffff0000) | (K[1] & 0x0000ffff),
  	                (K[3] << 16) | (K[3] >>> 16), (K[1] & 0xffff0000) | (K[2] & 0x0000ffff),
  	                (K[0] << 16) | (K[0] >>> 16), (K[2] & 0xffff0000) | (K[3] & 0x0000ffff),
  	                (K[1] << 16) | (K[1] >>> 16), (K[3] & 0xffff0000) | (K[0] & 0x0000ffff)
  	            ];
  
  	            // Carry bit
  	            this._b = 0;
  
  	            // Iterate the system four times
  	            for (var i = 0; i < 4; i++) {
  	                nextState.call(this);
  	            }
  
  	            // Modify the counters
  	            for (var i = 0; i < 8; i++) {
  	                C[i] ^= X[(i + 4) & 7];
  	            }
  
  	            // IV setup
  	            if (iv) {
  	                // Shortcuts
  	                var IV = iv.words;
  	                var IV_0 = IV[0];
  	                var IV_1 = IV[1];
  
  	                // Generate four subvectors
  	                var i0 = (((IV_0 << 8) | (IV_0 >>> 24)) & 0x00ff00ff) | (((IV_0 << 24) | (IV_0 >>> 8)) & 0xff00ff00);
  	                var i2 = (((IV_1 << 8) | (IV_1 >>> 24)) & 0x00ff00ff) | (((IV_1 << 24) | (IV_1 >>> 8)) & 0xff00ff00);
  	                var i1 = (i0 >>> 16) | (i2 & 0xffff0000);
  	                var i3 = (i2 << 16)  | (i0 & 0x0000ffff);
  
  	                // Modify counter values
  	                C[0] ^= i0;
  	                C[1] ^= i1;
  	                C[2] ^= i2;
  	                C[3] ^= i3;
  	                C[4] ^= i0;
  	                C[5] ^= i1;
  	                C[6] ^= i2;
  	                C[7] ^= i3;
  
  	                // Iterate the system four times
  	                for (var i = 0; i < 4; i++) {
  	                    nextState.call(this);
  	                }
  	            }
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcut
  	            var X = this._X;
  
  	            // Iterate the system
  	            nextState.call(this);
  
  	            // Generate four keystream words
  	            S[0] = X[0] ^ (X[5] >>> 16) ^ (X[3] << 16);
  	            S[1] = X[2] ^ (X[7] >>> 16) ^ (X[5] << 16);
  	            S[2] = X[4] ^ (X[1] >>> 16) ^ (X[7] << 16);
  	            S[3] = X[6] ^ (X[3] >>> 16) ^ (X[1] << 16);
  
  	            for (var i = 0; i < 4; i++) {
  	                // Swap endian
  	                S[i] = (((S[i] << 8)  | (S[i] >>> 24)) & 0x00ff00ff) |
  	                       (((S[i] << 24) | (S[i] >>> 8))  & 0xff00ff00);
  
  	                // Encrypt
  	                M[offset + i] ^= S[i];
  	            }
  	        },
  
  	        blockSize: 128/32,
  
  	        ivSize: 64/32
  	    });
  
  	    function nextState() {
  	        // Shortcuts
  	        var X = this._X;
  	        var C = this._C;
  
  	        // Save old counter values
  	        for (var i = 0; i < 8; i++) {
  	            C_[i] = C[i];
  	        }
  
  	        // Calculate new counter values
  	        C[0] = (C[0] + 0x4d34d34d + this._b) | 0;
  	        C[1] = (C[1] + 0xd34d34d3 + ((C[0] >>> 0) < (C_[0] >>> 0) ? 1 : 0)) | 0;
  	        C[2] = (C[2] + 0x34d34d34 + ((C[1] >>> 0) < (C_[1] >>> 0) ? 1 : 0)) | 0;
  	        C[3] = (C[3] + 0x4d34d34d + ((C[2] >>> 0) < (C_[2] >>> 0) ? 1 : 0)) | 0;
  	        C[4] = (C[4] + 0xd34d34d3 + ((C[3] >>> 0) < (C_[3] >>> 0) ? 1 : 0)) | 0;
  	        C[5] = (C[5] + 0x34d34d34 + ((C[4] >>> 0) < (C_[4] >>> 0) ? 1 : 0)) | 0;
  	        C[6] = (C[6] + 0x4d34d34d + ((C[5] >>> 0) < (C_[5] >>> 0) ? 1 : 0)) | 0;
  	        C[7] = (C[7] + 0xd34d34d3 + ((C[6] >>> 0) < (C_[6] >>> 0) ? 1 : 0)) | 0;
  	        this._b = (C[7] >>> 0) < (C_[7] >>> 0) ? 1 : 0;
  
  	        // Calculate the g-values
  	        for (var i = 0; i < 8; i++) {
  	            var gx = X[i] + C[i];
  
  	            // Construct high and low argument for squaring
  	            var ga = gx & 0xffff;
  	            var gb = gx >>> 16;
  
  	            // Calculate high and low result of squaring
  	            var gh = ((((ga * ga) >>> 17) + ga * gb) >>> 15) + gb * gb;
  	            var gl = (((gx & 0xffff0000) * gx) | 0) + (((gx & 0x0000ffff) * gx) | 0);
  
  	            // High XOR low
  	            G[i] = gh ^ gl;
  	        }
  
  	        // Calculate new state values
  	        X[0] = (G[0] + ((G[7] << 16) | (G[7] >>> 16)) + ((G[6] << 16) | (G[6] >>> 16))) | 0;
  	        X[1] = (G[1] + ((G[0] << 8)  | (G[0] >>> 24)) + G[7]) | 0;
  	        X[2] = (G[2] + ((G[1] << 16) | (G[1] >>> 16)) + ((G[0] << 16) | (G[0] >>> 16))) | 0;
  	        X[3] = (G[3] + ((G[2] << 8)  | (G[2] >>> 24)) + G[1]) | 0;
  	        X[4] = (G[4] + ((G[3] << 16) | (G[3] >>> 16)) + ((G[2] << 16) | (G[2] >>> 16))) | 0;
  	        X[5] = (G[5] + ((G[4] << 8)  | (G[4] >>> 24)) + G[3]) | 0;
  	        X[6] = (G[6] + ((G[5] << 16) | (G[5] >>> 16)) + ((G[4] << 16) | (G[4] >>> 16))) | 0;
  	        X[7] = (G[7] + ((G[6] << 8)  | (G[6] >>> 24)) + G[5]) | 0;
  	    }
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.Rabbit.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.Rabbit.decrypt(ciphertext, key, cfg);
  	     */
  	    C.Rabbit = StreamCipher._createHelper(Rabbit);
  	}());
  
  
  	return CryptoJS.Rabbit;
  
  }));
  },{"./cipher-core":60,"./core":61,"./enc-base64":62,"./evpkdf":64,"./md5":69}],83:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var StreamCipher = C_lib.StreamCipher;
  	    var C_algo = C.algo;
  
  	    /**
  	     * RC4 stream cipher algorithm.
  	     */
  	    var RC4 = C_algo.RC4 = StreamCipher.extend({
  	        _doReset: function () {
  	            // Shortcuts
  	            var key = this._key;
  	            var keyWords = key.words;
  	            var keySigBytes = key.sigBytes;
  
  	            // Init sbox
  	            var S = this._S = [];
  	            for (var i = 0; i < 256; i++) {
  	                S[i] = i;
  	            }
  
  	            // Key setup
  	            for (var i = 0, j = 0; i < 256; i++) {
  	                var keyByteIndex = i % keySigBytes;
  	                var keyByte = (keyWords[keyByteIndex >>> 2] >>> (24 - (keyByteIndex % 4) * 8)) & 0xff;
  
  	                j = (j + S[i] + keyByte) % 256;
  
  	                // Swap
  	                var t = S[i];
  	                S[i] = S[j];
  	                S[j] = t;
  	            }
  
  	            // Counters
  	            this._i = this._j = 0;
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            M[offset] ^= generateKeystreamWord.call(this);
  	        },
  
  	        keySize: 256/32,
  
  	        ivSize: 0
  	    });
  
  	    function generateKeystreamWord() {
  	        // Shortcuts
  	        var S = this._S;
  	        var i = this._i;
  	        var j = this._j;
  
  	        // Generate keystream word
  	        var keystreamWord = 0;
  	        for (var n = 0; n < 4; n++) {
  	            i = (i + 1) % 256;
  	            j = (j + S[i]) % 256;
  
  	            // Swap
  	            var t = S[i];
  	            S[i] = S[j];
  	            S[j] = t;
  
  	            keystreamWord |= S[(S[i] + S[j]) % 256] << (24 - n * 8);
  	        }
  
  	        // Update counters
  	        this._i = i;
  	        this._j = j;
  
  	        return keystreamWord;
  	    }
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.RC4.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.RC4.decrypt(ciphertext, key, cfg);
  	     */
  	    C.RC4 = StreamCipher._createHelper(RC4);
  
  	    /**
  	     * Modified RC4 stream cipher algorithm.
  	     */
  	    var RC4Drop = C_algo.RC4Drop = RC4.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {number} drop The number of keystream words to drop. Default 192
  	         */
  	        cfg: RC4.cfg.extend({
  	            drop: 192
  	        }),
  
  	        _doReset: function () {
  	            RC4._doReset.call(this);
  
  	            // Drop
  	            for (var i = this.cfg.drop; i > 0; i--) {
  	                generateKeystreamWord.call(this);
  	            }
  	        }
  	    });
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.RC4Drop.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.RC4Drop.decrypt(ciphertext, key, cfg);
  	     */
  	    C.RC4Drop = StreamCipher._createHelper(RC4Drop);
  	}());
  
  
  	return CryptoJS.RC4;
  
  }));
  },{"./cipher-core":60,"./core":61,"./enc-base64":62,"./evpkdf":64,"./md5":69}],84:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	/** @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.
  	*/
  
  	(function (Math) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var Hasher = C_lib.Hasher;
  	    var C_algo = C.algo;
  
  	    // Constants table
  	    var _zl = WordArray.create([
  	        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 = WordArray.create([
  	        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 = WordArray.create([
  	         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 = WordArray.create([
  	        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 =  WordArray.create([ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]);
  	    var _hr =  WordArray.create([ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]);
  
  	    /**
  	     * RIPEMD160 hash algorithm.
  	     */
  	    var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({
  	        _doReset: function () {
  	            this._hash  = WordArray.create([0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]);
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  
  	            // Swap endian
  	            for (var i = 0; i < 16; i++) {
  	                // Shortcuts
  	                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)
  	                );
  	            }
  	            // Shortcut
  	            var H  = this._hash.words;
  	            var hl = _hl.words;
  	            var hr = _hr.words;
  	            var zl = _zl.words;
  	            var zr = _zr.words;
  	            var sl = _sl.words;
  	            var sr = _sr.words;
  
  	            // 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;
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
  	                (((nBitsTotal << 8)  | (nBitsTotal >>> 24)) & 0x00ff00ff) |
  	                (((nBitsTotal << 24) | (nBitsTotal >>> 8))  & 0xff00ff00)
  	            );
  	            data.sigBytes = (dataWords.length + 1) * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Shortcuts
  	            var hash = this._hash;
  	            var H = hash.words;
  
  	            // 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);
  	            }
  
  	            // Return final computed hash
  	            return hash;
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  	            clone._hash = this._hash.clone();
  
  	            return clone;
  	        }
  	    });
  
  
  	    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));
  	    }
  
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.RIPEMD160('message');
  	     *     var hash = CryptoJS.RIPEMD160(wordArray);
  	     */
  	    C.RIPEMD160 = Hasher._createHelper(RIPEMD160);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacRIPEMD160(message, key);
  	     */
  	    C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);
  	}(Math));
  
  
  	return CryptoJS.RIPEMD160;
  
  }));
  },{"./core":61}],85:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var Hasher = C_lib.Hasher;
  	    var C_algo = C.algo;
  
  	    // Reusable object
  	    var W = [];
  
  	    /**
  	     * SHA-1 hash algorithm.
  	     */
  	    var SHA1 = C_algo.SHA1 = Hasher.extend({
  	        _doReset: function () {
  	            this._hash = new WordArray.init([
  	                0x67452301, 0xefcdab89,
  	                0x98badcfe, 0x10325476,
  	                0xc3d2e1f0
  	            ]);
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcut
  	            var H = this._hash.words;
  
  	            // Working variables
  	            var a = H[0];
  	            var b = H[1];
  	            var c = H[2];
  	            var d = H[3];
  	            var e = H[4];
  
  	            // Computation
  	            for (var i = 0; i < 80; i++) {
  	                if (i < 16) {
  	                    W[i] = M[offset + i] | 0;
  	                } else {
  	                    var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
  	                    W[i] = (n << 1) | (n >>> 31);
  	                }
  
  	                var t = ((a << 5) | (a >>> 27)) + e + W[i];
  	                if (i < 20) {
  	                    t += ((b & c) | (~b & d)) + 0x5a827999;
  	                } else if (i < 40) {
  	                    t += (b ^ c ^ d) + 0x6ed9eba1;
  	                } else if (i < 60) {
  	                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
  	                } else /* if (i < 80) */ {
  	                    t += (b ^ c ^ d) - 0x359d3e2a;
  	                }
  
  	                e = d;
  	                d = c;
  	                c = (b << 30) | (b >>> 2);
  	                b = a;
  	                a = t;
  	            }
  
  	            // Intermediate hash value
  	            H[0] = (H[0] + a) | 0;
  	            H[1] = (H[1] + b) | 0;
  	            H[2] = (H[2] + c) | 0;
  	            H[3] = (H[3] + d) | 0;
  	            H[4] = (H[4] + e) | 0;
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
  	            data.sigBytes = dataWords.length * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Return final computed hash
  	            return this._hash;
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  	            clone._hash = this._hash.clone();
  
  	            return clone;
  	        }
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA1('message');
  	     *     var hash = CryptoJS.SHA1(wordArray);
  	     */
  	    C.SHA1 = Hasher._createHelper(SHA1);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA1(message, key);
  	     */
  	    C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
  	}());
  
  
  	return CryptoJS.SHA1;
  
  }));
  },{"./core":61}],86:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./sha256"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./sha256"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var C_algo = C.algo;
  	    var SHA256 = C_algo.SHA256;
  
  	    /**
  	     * SHA-224 hash algorithm.
  	     */
  	    var SHA224 = C_algo.SHA224 = SHA256.extend({
  	        _doReset: function () {
  	            this._hash = new WordArray.init([
  	                0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,
  	                0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
  	            ]);
  	        },
  
  	        _doFinalize: function () {
  	            var hash = SHA256._doFinalize.call(this);
  
  	            hash.sigBytes -= 4;
  
  	            return hash;
  	        }
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA224('message');
  	     *     var hash = CryptoJS.SHA224(wordArray);
  	     */
  	    C.SHA224 = SHA256._createHelper(SHA224);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA224(message, key);
  	     */
  	    C.HmacSHA224 = SHA256._createHmacHelper(SHA224);
  	}());
  
  
  	return CryptoJS.SHA224;
  
  }));
  },{"./core":61,"./sha256":87}],87:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function (Math) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var Hasher = C_lib.Hasher;
  	    var C_algo = C.algo;
  
  	    // Initialization and round constants tables
  	    var H = [];
  	    var K = [];
  
  	    // Compute constants
  	    (function () {
  	        function isPrime(n) {
  	            var sqrtN = Math.sqrt(n);
  	            for (var factor = 2; factor <= sqrtN; factor++) {
  	                if (!(n % factor)) {
  	                    return false;
  	                }
  	            }
  
  	            return true;
  	        }
  
  	        function getFractionalBits(n) {
  	            return ((n - (n | 0)) * 0x100000000) | 0;
  	        }
  
  	        var n = 2;
  	        var nPrime = 0;
  	        while (nPrime < 64) {
  	            if (isPrime(n)) {
  	                if (nPrime < 8) {
  	                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
  	                }
  	                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
  
  	                nPrime++;
  	            }
  
  	            n++;
  	        }
  	    }());
  
  	    // Reusable object
  	    var W = [];
  
  	    /**
  	     * SHA-256 hash algorithm.
  	     */
  	    var SHA256 = C_algo.SHA256 = Hasher.extend({
  	        _doReset: function () {
  	            this._hash = new WordArray.init(H.slice(0));
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcut
  	            var H = this._hash.words;
  
  	            // Working variables
  	            var a = H[0];
  	            var b = H[1];
  	            var c = H[2];
  	            var d = H[3];
  	            var e = H[4];
  	            var f = H[5];
  	            var g = H[6];
  	            var h = H[7];
  
  	            // Computation
  	            for (var i = 0; i < 64; i++) {
  	                if (i < 16) {
  	                    W[i] = M[offset + i] | 0;
  	                } else {
  	                    var gamma0x = W[i - 15];
  	                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^
  	                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^
  	                                   (gamma0x >>> 3);
  
  	                    var gamma1x = W[i - 2];
  	                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^
  	                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^
  	                                   (gamma1x >>> 10);
  
  	                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
  	                }
  
  	                var ch  = (e & f) ^ (~e & g);
  	                var maj = (a & b) ^ (a & c) ^ (b & c);
  
  	                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
  	                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));
  
  	                var t1 = h + sigma1 + ch + K[i] + W[i];
  	                var t2 = sigma0 + maj;
  
  	                h = g;
  	                g = f;
  	                f = e;
  	                e = (d + t1) | 0;
  	                d = c;
  	                c = b;
  	                b = a;
  	                a = (t1 + t2) | 0;
  	            }
  
  	            // Intermediate hash value
  	            H[0] = (H[0] + a) | 0;
  	            H[1] = (H[1] + b) | 0;
  	            H[2] = (H[2] + c) | 0;
  	            H[3] = (H[3] + d) | 0;
  	            H[4] = (H[4] + e) | 0;
  	            H[5] = (H[5] + f) | 0;
  	            H[6] = (H[6] + g) | 0;
  	            H[7] = (H[7] + h) | 0;
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
  	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
  	            data.sigBytes = dataWords.length * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Return final computed hash
  	            return this._hash;
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  	            clone._hash = this._hash.clone();
  
  	            return clone;
  	        }
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA256('message');
  	     *     var hash = CryptoJS.SHA256(wordArray);
  	     */
  	    C.SHA256 = Hasher._createHelper(SHA256);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA256(message, key);
  	     */
  	    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
  	}(Math));
  
  
  	return CryptoJS.SHA256;
  
  }));
  },{"./core":61}],88:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./x64-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./x64-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function (Math) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var Hasher = C_lib.Hasher;
  	    var C_x64 = C.x64;
  	    var X64Word = C_x64.Word;
  	    var C_algo = C.algo;
  
  	    // Constants tables
  	    var RHO_OFFSETS = [];
  	    var PI_INDEXES  = [];
  	    var ROUND_CONSTANTS = [];
  
  	    // Compute Constants
  	    (function () {
  	        // Compute rho offset constants
  	        var x = 1, y = 0;
  	        for (var t = 0; t < 24; t++) {
  	            RHO_OFFSETS[x + 5 * y] = ((t + 1) * (t + 2) / 2) % 64;
  
  	            var newX = y % 5;
  	            var newY = (2 * x + 3 * y) % 5;
  	            x = newX;
  	            y = newY;
  	        }
  
  	        // Compute pi index constants
  	        for (var x = 0; x < 5; x++) {
  	            for (var y = 0; y < 5; y++) {
  	                PI_INDEXES[x + 5 * y] = y + ((2 * x + 3 * y) % 5) * 5;
  	            }
  	        }
  
  	        // Compute round constants
  	        var LFSR = 0x01;
  	        for (var i = 0; i < 24; i++) {
  	            var roundConstantMsw = 0;
  	            var roundConstantLsw = 0;
  
  	            for (var j = 0; j < 7; j++) {
  	                if (LFSR & 0x01) {
  	                    var bitPosition = (1 << j) - 1;
  	                    if (bitPosition < 32) {
  	                        roundConstantLsw ^= 1 << bitPosition;
  	                    } else /* if (bitPosition >= 32) */ {
  	                        roundConstantMsw ^= 1 << (bitPosition - 32);
  	                    }
  	                }
  
  	                // Compute next LFSR
  	                if (LFSR & 0x80) {
  	                    // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
  	                    LFSR = (LFSR << 1) ^ 0x71;
  	                } else {
  	                    LFSR <<= 1;
  	                }
  	            }
  
  	            ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
  	        }
  	    }());
  
  	    // Reusable objects for temporary values
  	    var T = [];
  	    (function () {
  	        for (var i = 0; i < 25; i++) {
  	            T[i] = X64Word.create();
  	        }
  	    }());
  
  	    /**
  	     * SHA-3 hash algorithm.
  	     */
  	    var SHA3 = C_algo.SHA3 = Hasher.extend({
  	        /**
  	         * Configuration options.
  	         *
  	         * @property {number} outputLength
  	         *   The desired number of bits in the output hash.
  	         *   Only values permitted are: 224, 256, 384, 512.
  	         *   Default: 512
  	         */
  	        cfg: Hasher.cfg.extend({
  	            outputLength: 512
  	        }),
  
  	        _doReset: function () {
  	            var state = this._state = []
  	            for (var i = 0; i < 25; i++) {
  	                state[i] = new X64Word.init();
  	            }
  
  	            this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcuts
  	            var state = this._state;
  	            var nBlockSizeLanes = this.blockSize / 2;
  
  	            // Absorb
  	            for (var i = 0; i < nBlockSizeLanes; i++) {
  	                // Shortcuts
  	                var M2i  = M[offset + 2 * i];
  	                var M2i1 = M[offset + 2 * i + 1];
  
  	                // Swap endian
  	                M2i = (
  	                    (((M2i << 8)  | (M2i >>> 24)) & 0x00ff00ff) |
  	                    (((M2i << 24) | (M2i >>> 8))  & 0xff00ff00)
  	                );
  	                M2i1 = (
  	                    (((M2i1 << 8)  | (M2i1 >>> 24)) & 0x00ff00ff) |
  	                    (((M2i1 << 24) | (M2i1 >>> 8))  & 0xff00ff00)
  	                );
  
  	                // Absorb message into state
  	                var lane = state[i];
  	                lane.high ^= M2i1;
  	                lane.low  ^= M2i;
  	            }
  
  	            // Rounds
  	            for (var round = 0; round < 24; round++) {
  	                // Theta
  	                for (var x = 0; x < 5; x++) {
  	                    // Mix column lanes
  	                    var tMsw = 0, tLsw = 0;
  	                    for (var y = 0; y < 5; y++) {
  	                        var lane = state[x + 5 * y];
  	                        tMsw ^= lane.high;
  	                        tLsw ^= lane.low;
  	                    }
  
  	                    // Temporary values
  	                    var Tx = T[x];
  	                    Tx.high = tMsw;
  	                    Tx.low  = tLsw;
  	                }
  	                for (var x = 0; x < 5; x++) {
  	                    // Shortcuts
  	                    var Tx4 = T[(x + 4) % 5];
  	                    var Tx1 = T[(x + 1) % 5];
  	                    var Tx1Msw = Tx1.high;
  	                    var Tx1Lsw = Tx1.low;
  
  	                    // Mix surrounding columns
  	                    var tMsw = Tx4.high ^ ((Tx1Msw << 1) | (Tx1Lsw >>> 31));
  	                    var tLsw = Tx4.low  ^ ((Tx1Lsw << 1) | (Tx1Msw >>> 31));
  	                    for (var y = 0; y < 5; y++) {
  	                        var lane = state[x + 5 * y];
  	                        lane.high ^= tMsw;
  	                        lane.low  ^= tLsw;
  	                    }
  	                }
  
  	                // Rho Pi
  	                for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
  	                    // Shortcuts
  	                    var lane = state[laneIndex];
  	                    var laneMsw = lane.high;
  	                    var laneLsw = lane.low;
  	                    var rhoOffset = RHO_OFFSETS[laneIndex];
  
  	                    // Rotate lanes
  	                    if (rhoOffset < 32) {
  	                        var tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
  	                        var tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
  	                    } else /* if (rhoOffset >= 32) */ {
  	                        var tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
  	                        var tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
  	                    }
  
  	                    // Transpose lanes
  	                    var TPiLane = T[PI_INDEXES[laneIndex]];
  	                    TPiLane.high = tMsw;
  	                    TPiLane.low  = tLsw;
  	                }
  
  	                // Rho pi at x = y = 0
  	                var T0 = T[0];
  	                var state0 = state[0];
  	                T0.high = state0.high;
  	                T0.low  = state0.low;
  
  	                // Chi
  	                for (var x = 0; x < 5; x++) {
  	                    for (var y = 0; y < 5; y++) {
  	                        // Shortcuts
  	                        var laneIndex = x + 5 * y;
  	                        var lane = state[laneIndex];
  	                        var TLane = T[laneIndex];
  	                        var Tx1Lane = T[((x + 1) % 5) + 5 * y];
  	                        var Tx2Lane = T[((x + 2) % 5) + 5 * y];
  
  	                        // Mix rows
  	                        lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
  	                        lane.low  = TLane.low  ^ (~Tx1Lane.low  & Tx2Lane.low);
  	                    }
  	                }
  
  	                // Iota
  	                var lane = state[0];
  	                var roundConstant = ROUND_CONSTANTS[round];
  	                lane.high ^= roundConstant.high;
  	                lane.low  ^= roundConstant.low;;
  	            }
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  	            var blockSizeBits = this.blockSize * 32;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
  	            dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
  	            data.sigBytes = dataWords.length * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Shortcuts
  	            var state = this._state;
  	            var outputLengthBytes = this.cfg.outputLength / 8;
  	            var outputLengthLanes = outputLengthBytes / 8;
  
  	            // Squeeze
  	            var hashWords = [];
  	            for (var i = 0; i < outputLengthLanes; i++) {
  	                // Shortcuts
  	                var lane = state[i];
  	                var laneMsw = lane.high;
  	                var laneLsw = lane.low;
  
  	                // Swap endian
  	                laneMsw = (
  	                    (((laneMsw << 8)  | (laneMsw >>> 24)) & 0x00ff00ff) |
  	                    (((laneMsw << 24) | (laneMsw >>> 8))  & 0xff00ff00)
  	                );
  	                laneLsw = (
  	                    (((laneLsw << 8)  | (laneLsw >>> 24)) & 0x00ff00ff) |
  	                    (((laneLsw << 24) | (laneLsw >>> 8))  & 0xff00ff00)
  	                );
  
  	                // Squeeze state to retrieve hash
  	                hashWords.push(laneLsw);
  	                hashWords.push(laneMsw);
  	            }
  
  	            // Return final computed hash
  	            return new WordArray.init(hashWords, outputLengthBytes);
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  
  	            var state = clone._state = this._state.slice(0);
  	            for (var i = 0; i < 25; i++) {
  	                state[i] = state[i].clone();
  	            }
  
  	            return clone;
  	        }
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA3('message');
  	     *     var hash = CryptoJS.SHA3(wordArray);
  	     */
  	    C.SHA3 = Hasher._createHelper(SHA3);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA3(message, key);
  	     */
  	    C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
  	}(Math));
  
  
  	return CryptoJS.SHA3;
  
  }));
  },{"./core":61,"./x64-core":92}],89:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./x64-core"), require("./sha512"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./x64-core", "./sha512"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_x64 = C.x64;
  	    var X64Word = C_x64.Word;
  	    var X64WordArray = C_x64.WordArray;
  	    var C_algo = C.algo;
  	    var SHA512 = C_algo.SHA512;
  
  	    /**
  	     * SHA-384 hash algorithm.
  	     */
  	    var SHA384 = C_algo.SHA384 = SHA512.extend({
  	        _doReset: function () {
  	            this._hash = new X64WordArray.init([
  	                new X64Word.init(0xcbbb9d5d, 0xc1059ed8), new X64Word.init(0x629a292a, 0x367cd507),
  	                new X64Word.init(0x9159015a, 0x3070dd17), new X64Word.init(0x152fecd8, 0xf70e5939),
  	                new X64Word.init(0x67332667, 0xffc00b31), new X64Word.init(0x8eb44a87, 0x68581511),
  	                new X64Word.init(0xdb0c2e0d, 0x64f98fa7), new X64Word.init(0x47b5481d, 0xbefa4fa4)
  	            ]);
  	        },
  
  	        _doFinalize: function () {
  	            var hash = SHA512._doFinalize.call(this);
  
  	            hash.sigBytes -= 16;
  
  	            return hash;
  	        }
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA384('message');
  	     *     var hash = CryptoJS.SHA384(wordArray);
  	     */
  	    C.SHA384 = SHA512._createHelper(SHA384);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA384(message, key);
  	     */
  	    C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
  	}());
  
  
  	return CryptoJS.SHA384;
  
  }));
  },{"./core":61,"./sha512":90,"./x64-core":92}],90:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./x64-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./x64-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Hasher = C_lib.Hasher;
  	    var C_x64 = C.x64;
  	    var X64Word = C_x64.Word;
  	    var X64WordArray = C_x64.WordArray;
  	    var C_algo = C.algo;
  
  	    function X64Word_create() {
  	        return X64Word.create.apply(X64Word, arguments);
  	    }
  
  	    // Constants
  	    var K = [
  	        X64Word_create(0x428a2f98, 0xd728ae22), X64Word_create(0x71374491, 0x23ef65cd),
  	        X64Word_create(0xb5c0fbcf, 0xec4d3b2f), X64Word_create(0xe9b5dba5, 0x8189dbbc),
  	        X64Word_create(0x3956c25b, 0xf348b538), X64Word_create(0x59f111f1, 0xb605d019),
  	        X64Word_create(0x923f82a4, 0xaf194f9b), X64Word_create(0xab1c5ed5, 0xda6d8118),
  	        X64Word_create(0xd807aa98, 0xa3030242), X64Word_create(0x12835b01, 0x45706fbe),
  	        X64Word_create(0x243185be, 0x4ee4b28c), X64Word_create(0x550c7dc3, 0xd5ffb4e2),
  	        X64Word_create(0x72be5d74, 0xf27b896f), X64Word_create(0x80deb1fe, 0x3b1696b1),
  	        X64Word_create(0x9bdc06a7, 0x25c71235), X64Word_create(0xc19bf174, 0xcf692694),
  	        X64Word_create(0xe49b69c1, 0x9ef14ad2), X64Word_create(0xefbe4786, 0x384f25e3),
  	        X64Word_create(0x0fc19dc6, 0x8b8cd5b5), X64Word_create(0x240ca1cc, 0x77ac9c65),
  	        X64Word_create(0x2de92c6f, 0x592b0275), X64Word_create(0x4a7484aa, 0x6ea6e483),
  	        X64Word_create(0x5cb0a9dc, 0xbd41fbd4), X64Word_create(0x76f988da, 0x831153b5),
  	        X64Word_create(0x983e5152, 0xee66dfab), X64Word_create(0xa831c66d, 0x2db43210),
  	        X64Word_create(0xb00327c8, 0x98fb213f), X64Word_create(0xbf597fc7, 0xbeef0ee4),
  	        X64Word_create(0xc6e00bf3, 0x3da88fc2), X64Word_create(0xd5a79147, 0x930aa725),
  	        X64Word_create(0x06ca6351, 0xe003826f), X64Word_create(0x14292967, 0x0a0e6e70),
  	        X64Word_create(0x27b70a85, 0x46d22ffc), X64Word_create(0x2e1b2138, 0x5c26c926),
  	        X64Word_create(0x4d2c6dfc, 0x5ac42aed), X64Word_create(0x53380d13, 0x9d95b3df),
  	        X64Word_create(0x650a7354, 0x8baf63de), X64Word_create(0x766a0abb, 0x3c77b2a8),
  	        X64Word_create(0x81c2c92e, 0x47edaee6), X64Word_create(0x92722c85, 0x1482353b),
  	        X64Word_create(0xa2bfe8a1, 0x4cf10364), X64Word_create(0xa81a664b, 0xbc423001),
  	        X64Word_create(0xc24b8b70, 0xd0f89791), X64Word_create(0xc76c51a3, 0x0654be30),
  	        X64Word_create(0xd192e819, 0xd6ef5218), X64Word_create(0xd6990624, 0x5565a910),
  	        X64Word_create(0xf40e3585, 0x5771202a), X64Word_create(0x106aa070, 0x32bbd1b8),
  	        X64Word_create(0x19a4c116, 0xb8d2d0c8), X64Word_create(0x1e376c08, 0x5141ab53),
  	        X64Word_create(0x2748774c, 0xdf8eeb99), X64Word_create(0x34b0bcb5, 0xe19b48a8),
  	        X64Word_create(0x391c0cb3, 0xc5c95a63), X64Word_create(0x4ed8aa4a, 0xe3418acb),
  	        X64Word_create(0x5b9cca4f, 0x7763e373), X64Word_create(0x682e6ff3, 0xd6b2b8a3),
  	        X64Word_create(0x748f82ee, 0x5defb2fc), X64Word_create(0x78a5636f, 0x43172f60),
  	        X64Word_create(0x84c87814, 0xa1f0ab72), X64Word_create(0x8cc70208, 0x1a6439ec),
  	        X64Word_create(0x90befffa, 0x23631e28), X64Word_create(0xa4506ceb, 0xde82bde9),
  	        X64Word_create(0xbef9a3f7, 0xb2c67915), X64Word_create(0xc67178f2, 0xe372532b),
  	        X64Word_create(0xca273ece, 0xea26619c), X64Word_create(0xd186b8c7, 0x21c0c207),
  	        X64Word_create(0xeada7dd6, 0xcde0eb1e), X64Word_create(0xf57d4f7f, 0xee6ed178),
  	        X64Word_create(0x06f067aa, 0x72176fba), X64Word_create(0x0a637dc5, 0xa2c898a6),
  	        X64Word_create(0x113f9804, 0xbef90dae), X64Word_create(0x1b710b35, 0x131c471b),
  	        X64Word_create(0x28db77f5, 0x23047d84), X64Word_create(0x32caab7b, 0x40c72493),
  	        X64Word_create(0x3c9ebe0a, 0x15c9bebc), X64Word_create(0x431d67c4, 0x9c100d4c),
  	        X64Word_create(0x4cc5d4be, 0xcb3e42b6), X64Word_create(0x597f299c, 0xfc657e2a),
  	        X64Word_create(0x5fcb6fab, 0x3ad6faec), X64Word_create(0x6c44198c, 0x4a475817)
  	    ];
  
  	    // Reusable objects
  	    var W = [];
  	    (function () {
  	        for (var i = 0; i < 80; i++) {
  	            W[i] = X64Word_create();
  	        }
  	    }());
  
  	    /**
  	     * SHA-512 hash algorithm.
  	     */
  	    var SHA512 = C_algo.SHA512 = Hasher.extend({
  	        _doReset: function () {
  	            this._hash = new X64WordArray.init([
  	                new X64Word.init(0x6a09e667, 0xf3bcc908), new X64Word.init(0xbb67ae85, 0x84caa73b),
  	                new X64Word.init(0x3c6ef372, 0xfe94f82b), new X64Word.init(0xa54ff53a, 0x5f1d36f1),
  	                new X64Word.init(0x510e527f, 0xade682d1), new X64Word.init(0x9b05688c, 0x2b3e6c1f),
  	                new X64Word.init(0x1f83d9ab, 0xfb41bd6b), new X64Word.init(0x5be0cd19, 0x137e2179)
  	            ]);
  	        },
  
  	        _doProcessBlock: function (M, offset) {
  	            // Shortcuts
  	            var H = this._hash.words;
  
  	            var H0 = H[0];
  	            var H1 = H[1];
  	            var H2 = H[2];
  	            var H3 = H[3];
  	            var H4 = H[4];
  	            var H5 = H[5];
  	            var H6 = H[6];
  	            var H7 = H[7];
  
  	            var H0h = H0.high;
  	            var H0l = H0.low;
  	            var H1h = H1.high;
  	            var H1l = H1.low;
  	            var H2h = H2.high;
  	            var H2l = H2.low;
  	            var H3h = H3.high;
  	            var H3l = H3.low;
  	            var H4h = H4.high;
  	            var H4l = H4.low;
  	            var H5h = H5.high;
  	            var H5l = H5.low;
  	            var H6h = H6.high;
  	            var H6l = H6.low;
  	            var H7h = H7.high;
  	            var H7l = H7.low;
  
  	            // Working variables
  	            var ah = H0h;
  	            var al = H0l;
  	            var bh = H1h;
  	            var bl = H1l;
  	            var ch = H2h;
  	            var cl = H2l;
  	            var dh = H3h;
  	            var dl = H3l;
  	            var eh = H4h;
  	            var el = H4l;
  	            var fh = H5h;
  	            var fl = H5l;
  	            var gh = H6h;
  	            var gl = H6l;
  	            var hh = H7h;
  	            var hl = H7l;
  
  	            // Rounds
  	            for (var i = 0; i < 80; i++) {
  	                // Shortcut
  	                var Wi = W[i];
  
  	                // Extend message
  	                if (i < 16) {
  	                    var Wih = Wi.high = M[offset + i * 2]     | 0;
  	                    var Wil = Wi.low  = M[offset + i * 2 + 1] | 0;
  	                } else {
  	                    // Gamma0
  	                    var gamma0x  = W[i - 15];
  	                    var gamma0xh = gamma0x.high;
  	                    var gamma0xl = gamma0x.low;
  	                    var gamma0h  = ((gamma0xh >>> 1) | (gamma0xl << 31)) ^ ((gamma0xh >>> 8) | (gamma0xl << 24)) ^ (gamma0xh >>> 7);
  	                    var gamma0l  = ((gamma0xl >>> 1) | (gamma0xh << 31)) ^ ((gamma0xl >>> 8) | (gamma0xh << 24)) ^ ((gamma0xl >>> 7) | (gamma0xh << 25));
  
  	                    // Gamma1
  	                    var gamma1x  = W[i - 2];
  	                    var gamma1xh = gamma1x.high;
  	                    var gamma1xl = gamma1x.low;
  	                    var gamma1h  = ((gamma1xh >>> 19) | (gamma1xl << 13)) ^ ((gamma1xh << 3) | (gamma1xl >>> 29)) ^ (gamma1xh >>> 6);
  	                    var gamma1l  = ((gamma1xl >>> 19) | (gamma1xh << 13)) ^ ((gamma1xl << 3) | (gamma1xh >>> 29)) ^ ((gamma1xl >>> 6) | (gamma1xh << 26));
  
  	                    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
  	                    var Wi7  = W[i - 7];
  	                    var Wi7h = Wi7.high;
  	                    var Wi7l = Wi7.low;
  
  	                    var Wi16  = W[i - 16];
  	                    var Wi16h = Wi16.high;
  	                    var Wi16l = Wi16.low;
  
  	                    var Wil = gamma0l + Wi7l;
  	                    var Wih = gamma0h + Wi7h + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0);
  	                    var Wil = Wil + gamma1l;
  	                    var Wih = Wih + gamma1h + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0);
  	                    var Wil = Wil + Wi16l;
  	                    var Wih = Wih + Wi16h + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0);
  
  	                    Wi.high = Wih;
  	                    Wi.low  = Wil;
  	                }
  
  	                var chh  = (eh & fh) ^ (~eh & gh);
  	                var chl  = (el & fl) ^ (~el & gl);
  	                var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
  	                var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
  
  	                var sigma0h = ((ah >>> 28) | (al << 4))  ^ ((ah << 30)  | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
  	                var sigma0l = ((al >>> 28) | (ah << 4))  ^ ((al << 30)  | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
  	                var sigma1h = ((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9));
  	                var sigma1l = ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9));
  
  	                // t1 = h + sigma1 + ch + K[i] + W[i]
  	                var Ki  = K[i];
  	                var Kih = Ki.high;
  	                var Kil = Ki.low;
  
  	                var t1l = hl + sigma1l;
  	                var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
  	                var t1l = t1l + chl;
  	                var t1h = t1h + chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
  	                var t1l = t1l + Kil;
  	                var t1h = t1h + Kih + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0);
  	                var t1l = t1l + Wil;
  	                var t1h = t1h + Wih + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0);
  
  	                // t2 = sigma0 + maj
  	                var t2l = sigma0l + majl;
  	                var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
  
  	                // Update working variables
  	                hh = gh;
  	                hl = gl;
  	                gh = fh;
  	                gl = fl;
  	                fh = eh;
  	                fl = el;
  	                el = (dl + t1l) | 0;
  	                eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
  	                dh = ch;
  	                dl = cl;
  	                ch = bh;
  	                cl = bl;
  	                bh = ah;
  	                bl = al;
  	                al = (t1l + t2l) | 0;
  	                ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
  	            }
  
  	            // Intermediate hash value
  	            H0l = H0.low  = (H0l + al);
  	            H0.high = (H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0));
  	            H1l = H1.low  = (H1l + bl);
  	            H1.high = (H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0));
  	            H2l = H2.low  = (H2l + cl);
  	            H2.high = (H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0));
  	            H3l = H3.low  = (H3l + dl);
  	            H3.high = (H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0));
  	            H4l = H4.low  = (H4l + el);
  	            H4.high = (H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0));
  	            H5l = H5.low  = (H5l + fl);
  	            H5.high = (H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0));
  	            H6l = H6.low  = (H6l + gl);
  	            H6.high = (H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0));
  	            H7l = H7.low  = (H7l + hl);
  	            H7.high = (H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0));
  	        },
  
  	        _doFinalize: function () {
  	            // Shortcuts
  	            var data = this._data;
  	            var dataWords = data.words;
  
  	            var nBitsTotal = this._nDataBytes * 8;
  	            var nBitsLeft = data.sigBytes * 8;
  
  	            // Add padding
  	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
  	            dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 30] = Math.floor(nBitsTotal / 0x100000000);
  	            dataWords[(((nBitsLeft + 128) >>> 10) << 5) + 31] = nBitsTotal;
  	            data.sigBytes = dataWords.length * 4;
  
  	            // Hash final blocks
  	            this._process();
  
  	            // Convert hash to 32-bit word array before returning
  	            var hash = this._hash.toX32();
  
  	            // Return final computed hash
  	            return hash;
  	        },
  
  	        clone: function () {
  	            var clone = Hasher.clone.call(this);
  	            clone._hash = this._hash.clone();
  
  	            return clone;
  	        },
  
  	        blockSize: 1024/32
  	    });
  
  	    /**
  	     * Shortcut function to the hasher's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     *
  	     * @return {WordArray} The hash.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hash = CryptoJS.SHA512('message');
  	     *     var hash = CryptoJS.SHA512(wordArray);
  	     */
  	    C.SHA512 = Hasher._createHelper(SHA512);
  
  	    /**
  	     * Shortcut function to the HMAC's object interface.
  	     *
  	     * @param {WordArray|string} message The message to hash.
  	     * @param {WordArray|string} key The secret key.
  	     *
  	     * @return {WordArray} The HMAC.
  	     *
  	     * @static
  	     *
  	     * @example
  	     *
  	     *     var hmac = CryptoJS.HmacSHA512(message, key);
  	     */
  	    C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
  	}());
  
  
  	return CryptoJS.SHA512;
  
  }));
  },{"./core":61,"./x64-core":92}],91:[function(require,module,exports){
  ;(function (root, factory, undef) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"), require("./enc-base64"), require("./md5"), require("./evpkdf"), require("./cipher-core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function () {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var WordArray = C_lib.WordArray;
  	    var BlockCipher = C_lib.BlockCipher;
  	    var C_algo = C.algo;
  
  	    // Permuted Choice 1 constants
  	    var PC1 = [
  	        57, 49, 41, 33, 25, 17, 9,  1,
  	        58, 50, 42, 34, 26, 18, 10, 2,
  	        59, 51, 43, 35, 27, 19, 11, 3,
  	        60, 52, 44, 36, 63, 55, 47, 39,
  	        31, 23, 15, 7,  62, 54, 46, 38,
  	        30, 22, 14, 6,  61, 53, 45, 37,
  	        29, 21, 13, 5,  28, 20, 12, 4
  	    ];
  
  	    // Permuted Choice 2 constants
  	    var PC2 = [
  	        14, 17, 11, 24, 1,  5,
  	        3,  28, 15, 6,  21, 10,
  	        23, 19, 12, 4,  26, 8,
  	        16, 7,  27, 20, 13, 2,
  	        41, 52, 31, 37, 47, 55,
  	        30, 40, 51, 45, 33, 48,
  	        44, 49, 39, 56, 34, 53,
  	        46, 42, 50, 36, 29, 32
  	    ];
  
  	    // Cumulative bit shift constants
  	    var BIT_SHIFTS = [1,  2,  4,  6,  8,  10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
  
  	    // SBOXes and round permutation constants
  	    var SBOX_P = [
  	        {
  	            0x0: 0x808200,
  	            0x10000000: 0x8000,
  	            0x20000000: 0x808002,
  	            0x30000000: 0x2,
  	            0x40000000: 0x200,
  	            0x50000000: 0x808202,
  	            0x60000000: 0x800202,
  	            0x70000000: 0x800000,
  	            0x80000000: 0x202,
  	            0x90000000: 0x800200,
  	            0xa0000000: 0x8200,
  	            0xb0000000: 0x808000,
  	            0xc0000000: 0x8002,
  	            0xd0000000: 0x800002,
  	            0xe0000000: 0x0,
  	            0xf0000000: 0x8202,
  	            0x8000000: 0x0,
  	            0x18000000: 0x808202,
  	            0x28000000: 0x8202,
  	            0x38000000: 0x8000,
  	            0x48000000: 0x808200,
  	            0x58000000: 0x200,
  	            0x68000000: 0x808002,
  	            0x78000000: 0x2,
  	            0x88000000: 0x800200,
  	            0x98000000: 0x8200,
  	            0xa8000000: 0x808000,
  	            0xb8000000: 0x800202,
  	            0xc8000000: 0x800002,
  	            0xd8000000: 0x8002,
  	            0xe8000000: 0x202,
  	            0xf8000000: 0x800000,
  	            0x1: 0x8000,
  	            0x10000001: 0x2,
  	            0x20000001: 0x808200,
  	            0x30000001: 0x800000,
  	            0x40000001: 0x808002,
  	            0x50000001: 0x8200,
  	            0x60000001: 0x200,
  	            0x70000001: 0x800202,
  	            0x80000001: 0x808202,
  	            0x90000001: 0x808000,
  	            0xa0000001: 0x800002,
  	            0xb0000001: 0x8202,
  	            0xc0000001: 0x202,
  	            0xd0000001: 0x800200,
  	            0xe0000001: 0x8002,
  	            0xf0000001: 0x0,
  	            0x8000001: 0x808202,
  	            0x18000001: 0x808000,
  	            0x28000001: 0x800000,
  	            0x38000001: 0x200,
  	            0x48000001: 0x8000,
  	            0x58000001: 0x800002,
  	            0x68000001: 0x2,
  	            0x78000001: 0x8202,
  	            0x88000001: 0x8002,
  	            0x98000001: 0x800202,
  	            0xa8000001: 0x202,
  	            0xb8000001: 0x808200,
  	            0xc8000001: 0x800200,
  	            0xd8000001: 0x0,
  	            0xe8000001: 0x8200,
  	            0xf8000001: 0x808002
  	        },
  	        {
  	            0x0: 0x40084010,
  	            0x1000000: 0x4000,
  	            0x2000000: 0x80000,
  	            0x3000000: 0x40080010,
  	            0x4000000: 0x40000010,
  	            0x5000000: 0x40084000,
  	            0x6000000: 0x40004000,
  	            0x7000000: 0x10,
  	            0x8000000: 0x84000,
  	            0x9000000: 0x40004010,
  	            0xa000000: 0x40000000,
  	            0xb000000: 0x84010,
  	            0xc000000: 0x80010,
  	            0xd000000: 0x0,
  	            0xe000000: 0x4010,
  	            0xf000000: 0x40080000,
  	            0x800000: 0x40004000,
  	            0x1800000: 0x84010,
  	            0x2800000: 0x10,
  	            0x3800000: 0x40004010,
  	            0x4800000: 0x40084010,
  	            0x5800000: 0x40000000,
  	            0x6800000: 0x80000,
  	            0x7800000: 0x40080010,
  	            0x8800000: 0x80010,
  	            0x9800000: 0x0,
  	            0xa800000: 0x4000,
  	            0xb800000: 0x40080000,
  	            0xc800000: 0x40000010,
  	            0xd800000: 0x84000,
  	            0xe800000: 0x40084000,
  	            0xf800000: 0x4010,
  	            0x10000000: 0x0,
  	            0x11000000: 0x40080010,
  	            0x12000000: 0x40004010,
  	            0x13000000: 0x40084000,
  	            0x14000000: 0x40080000,
  	            0x15000000: 0x10,
  	            0x16000000: 0x84010,
  	            0x17000000: 0x4000,
  	            0x18000000: 0x4010,
  	            0x19000000: 0x80000,
  	            0x1a000000: 0x80010,
  	            0x1b000000: 0x40000010,
  	            0x1c000000: 0x84000,
  	            0x1d000000: 0x40004000,
  	            0x1e000000: 0x40000000,
  	            0x1f000000: 0x40084010,
  	            0x10800000: 0x84010,
  	            0x11800000: 0x80000,
  	            0x12800000: 0x40080000,
  	            0x13800000: 0x4000,
  	            0x14800000: 0x40004000,
  	            0x15800000: 0x40084010,
  	            0x16800000: 0x10,
  	            0x17800000: 0x40000000,
  	            0x18800000: 0x40084000,
  	            0x19800000: 0x40000010,
  	            0x1a800000: 0x40004010,
  	            0x1b800000: 0x80010,
  	            0x1c800000: 0x0,
  	            0x1d800000: 0x4010,
  	            0x1e800000: 0x40080010,
  	            0x1f800000: 0x84000
  	        },
  	        {
  	            0x0: 0x104,
  	            0x100000: 0x0,
  	            0x200000: 0x4000100,
  	            0x300000: 0x10104,
  	            0x400000: 0x10004,
  	            0x500000: 0x4000004,
  	            0x600000: 0x4010104,
  	            0x700000: 0x4010000,
  	            0x800000: 0x4000000,
  	            0x900000: 0x4010100,
  	            0xa00000: 0x10100,
  	            0xb00000: 0x4010004,
  	            0xc00000: 0x4000104,
  	            0xd00000: 0x10000,
  	            0xe00000: 0x4,
  	            0xf00000: 0x100,
  	            0x80000: 0x4010100,
  	            0x180000: 0x4010004,
  	            0x280000: 0x0,
  	            0x380000: 0x4000100,
  	            0x480000: 0x4000004,
  	            0x580000: 0x10000,
  	            0x680000: 0x10004,
  	            0x780000: 0x104,
  	            0x880000: 0x4,
  	            0x980000: 0x100,
  	            0xa80000: 0x4010000,
  	            0xb80000: 0x10104,
  	            0xc80000: 0x10100,
  	            0xd80000: 0x4000104,
  	            0xe80000: 0x4010104,
  	            0xf80000: 0x4000000,
  	            0x1000000: 0x4010100,
  	            0x1100000: 0x10004,
  	            0x1200000: 0x10000,
  	            0x1300000: 0x4000100,
  	            0x1400000: 0x100,
  	            0x1500000: 0x4010104,
  	            0x1600000: 0x4000004,
  	            0x1700000: 0x0,
  	            0x1800000: 0x4000104,
  	            0x1900000: 0x4000000,
  	            0x1a00000: 0x4,
  	            0x1b00000: 0x10100,
  	            0x1c00000: 0x4010000,
  	            0x1d00000: 0x104,
  	            0x1e00000: 0x10104,
  	            0x1f00000: 0x4010004,
  	            0x1080000: 0x4000000,
  	            0x1180000: 0x104,
  	            0x1280000: 0x4010100,
  	            0x1380000: 0x0,
  	            0x1480000: 0x10004,
  	            0x1580000: 0x4000100,
  	            0x1680000: 0x100,
  	            0x1780000: 0x4010004,
  	            0x1880000: 0x10000,
  	            0x1980000: 0x4010104,
  	            0x1a80000: 0x10104,
  	            0x1b80000: 0x4000004,
  	            0x1c80000: 0x4000104,
  	            0x1d80000: 0x4010000,
  	            0x1e80000: 0x4,
  	            0x1f80000: 0x10100
  	        },
  	        {
  	            0x0: 0x80401000,
  	            0x10000: 0x80001040,
  	            0x20000: 0x401040,
  	            0x30000: 0x80400000,
  	            0x40000: 0x0,
  	            0x50000: 0x401000,
  	            0x60000: 0x80000040,
  	            0x70000: 0x400040,
  	            0x80000: 0x80000000,
  	            0x90000: 0x400000,
  	            0xa0000: 0x40,
  	            0xb0000: 0x80001000,
  	            0xc0000: 0x80400040,
  	            0xd0000: 0x1040,
  	            0xe0000: 0x1000,
  	            0xf0000: 0x80401040,
  	            0x8000: 0x80001040,
  	            0x18000: 0x40,
  	            0x28000: 0x80400040,
  	            0x38000: 0x80001000,
  	            0x48000: 0x401000,
  	            0x58000: 0x80401040,
  	            0x68000: 0x0,
  	            0x78000: 0x80400000,
  	            0x88000: 0x1000,
  	            0x98000: 0x80401000,
  	            0xa8000: 0x400000,
  	            0xb8000: 0x1040,
  	            0xc8000: 0x80000000,
  	            0xd8000: 0x400040,
  	            0xe8000: 0x401040,
  	            0xf8000: 0x80000040,
  	            0x100000: 0x400040,
  	            0x110000: 0x401000,
  	            0x120000: 0x80000040,
  	            0x130000: 0x0,
  	            0x140000: 0x1040,
  	            0x150000: 0x80400040,
  	            0x160000: 0x80401000,
  	            0x170000: 0x80001040,
  	            0x180000: 0x80401040,
  	            0x190000: 0x80000000,
  	            0x1a0000: 0x80400000,
  	            0x1b0000: 0x401040,
  	            0x1c0000: 0x80001000,
  	            0x1d0000: 0x400000,
  	            0x1e0000: 0x40,
  	            0x1f0000: 0x1000,
  	            0x108000: 0x80400000,
  	            0x118000: 0x80401040,
  	            0x128000: 0x0,
  	            0x138000: 0x401000,
  	            0x148000: 0x400040,
  	            0x158000: 0x80000000,
  	            0x168000: 0x80001040,
  	            0x178000: 0x40,
  	            0x188000: 0x80000040,
  	            0x198000: 0x1000,
  	            0x1a8000: 0x80001000,
  	            0x1b8000: 0x80400040,
  	            0x1c8000: 0x1040,
  	            0x1d8000: 0x80401000,
  	            0x1e8000: 0x400000,
  	            0x1f8000: 0x401040
  	        },
  	        {
  	            0x0: 0x80,
  	            0x1000: 0x1040000,
  	            0x2000: 0x40000,
  	            0x3000: 0x20000000,
  	            0x4000: 0x20040080,
  	            0x5000: 0x1000080,
  	            0x6000: 0x21000080,
  	            0x7000: 0x40080,
  	            0x8000: 0x1000000,
  	            0x9000: 0x20040000,
  	            0xa000: 0x20000080,
  	            0xb000: 0x21040080,
  	            0xc000: 0x21040000,
  	            0xd000: 0x0,
  	            0xe000: 0x1040080,
  	            0xf000: 0x21000000,
  	            0x800: 0x1040080,
  	            0x1800: 0x21000080,
  	            0x2800: 0x80,
  	            0x3800: 0x1040000,
  	            0x4800: 0x40000,
  	            0x5800: 0x20040080,
  	            0x6800: 0x21040000,
  	            0x7800: 0x20000000,
  	            0x8800: 0x20040000,
  	            0x9800: 0x0,
  	            0xa800: 0x21040080,
  	            0xb800: 0x1000080,
  	            0xc800: 0x20000080,
  	            0xd800: 0x21000000,
  	            0xe800: 0x1000000,
  	            0xf800: 0x40080,
  	            0x10000: 0x40000,
  	            0x11000: 0x80,
  	            0x12000: 0x20000000,
  	            0x13000: 0x21000080,
  	            0x14000: 0x1000080,
  	            0x15000: 0x21040000,
  	            0x16000: 0x20040080,
  	            0x17000: 0x1000000,
  	            0x18000: 0x21040080,
  	            0x19000: 0x21000000,
  	            0x1a000: 0x1040000,
  	            0x1b000: 0x20040000,
  	            0x1c000: 0x40080,
  	            0x1d000: 0x20000080,
  	            0x1e000: 0x0,
  	            0x1f000: 0x1040080,
  	            0x10800: 0x21000080,
  	            0x11800: 0x1000000,
  	            0x12800: 0x1040000,
  	            0x13800: 0x20040080,
  	            0x14800: 0x20000000,
  	            0x15800: 0x1040080,
  	            0x16800: 0x80,
  	            0x17800: 0x21040000,
  	            0x18800: 0x40080,
  	            0x19800: 0x21040080,
  	            0x1a800: 0x0,
  	            0x1b800: 0x21000000,
  	            0x1c800: 0x1000080,
  	            0x1d800: 0x40000,
  	            0x1e800: 0x20040000,
  	            0x1f800: 0x20000080
  	        },
  	        {
  	            0x0: 0x10000008,
  	            0x100: 0x2000,
  	            0x200: 0x10200000,
  	            0x300: 0x10202008,
  	            0x400: 0x10002000,
  	            0x500: 0x200000,
  	            0x600: 0x200008,
  	            0x700: 0x10000000,
  	            0x800: 0x0,
  	            0x900: 0x10002008,
  	            0xa00: 0x202000,
  	            0xb00: 0x8,
  	            0xc00: 0x10200008,
  	            0xd00: 0x202008,
  	            0xe00: 0x2008,
  	            0xf00: 0x10202000,
  	            0x80: 0x10200000,
  	            0x180: 0x10202008,
  	            0x280: 0x8,
  	            0x380: 0x200000,
  	            0x480: 0x202008,
  	            0x580: 0x10000008,
  	            0x680: 0x10002000,
  	            0x780: 0x2008,
  	            0x880: 0x200008,
  	            0x980: 0x2000,
  	            0xa80: 0x10002008,
  	            0xb80: 0x10200008,
  	            0xc80: 0x0,
  	            0xd80: 0x10202000,
  	            0xe80: 0x202000,
  	            0xf80: 0x10000000,
  	            0x1000: 0x10002000,
  	            0x1100: 0x10200008,
  	            0x1200: 0x10202008,
  	            0x1300: 0x2008,
  	            0x1400: 0x200000,
  	            0x1500: 0x10000000,
  	            0x1600: 0x10000008,
  	            0x1700: 0x202000,
  	            0x1800: 0x202008,
  	            0x1900: 0x0,
  	            0x1a00: 0x8,
  	            0x1b00: 0x10200000,
  	            0x1c00: 0x2000,
  	            0x1d00: 0x10002008,
  	            0x1e00: 0x10202000,
  	            0x1f00: 0x200008,
  	            0x1080: 0x8,
  	            0x1180: 0x202000,
  	            0x1280: 0x200000,
  	            0x1380: 0x10000008,
  	            0x1480: 0x10002000,
  	            0x1580: 0x2008,
  	            0x1680: 0x10202008,
  	            0x1780: 0x10200000,
  	            0x1880: 0x10202000,
  	            0x1980: 0x10200008,
  	            0x1a80: 0x2000,
  	            0x1b80: 0x202008,
  	            0x1c80: 0x200008,
  	            0x1d80: 0x0,
  	            0x1e80: 0x10000000,
  	            0x1f80: 0x10002008
  	        },
  	        {
  	            0x0: 0x100000,
  	            0x10: 0x2000401,
  	            0x20: 0x400,
  	            0x30: 0x100401,
  	            0x40: 0x2100401,
  	            0x50: 0x0,
  	            0x60: 0x1,
  	            0x70: 0x2100001,
  	            0x80: 0x2000400,
  	            0x90: 0x100001,
  	            0xa0: 0x2000001,
  	            0xb0: 0x2100400,
  	            0xc0: 0x2100000,
  	            0xd0: 0x401,
  	            0xe0: 0x100400,
  	            0xf0: 0x2000000,
  	            0x8: 0x2100001,
  	            0x18: 0x0,
  	            0x28: 0x2000401,
  	            0x38: 0x2100400,
  	            0x48: 0x100000,
  	            0x58: 0x2000001,
  	            0x68: 0x2000000,
  	            0x78: 0x401,
  	            0x88: 0x100401,
  	            0x98: 0x2000400,
  	            0xa8: 0x2100000,
  	            0xb8: 0x100001,
  	            0xc8: 0x400,
  	            0xd8: 0x2100401,
  	            0xe8: 0x1,
  	            0xf8: 0x100400,
  	            0x100: 0x2000000,
  	            0x110: 0x100000,
  	            0x120: 0x2000401,
  	            0x130: 0x2100001,
  	            0x140: 0x100001,
  	            0x150: 0x2000400,
  	            0x160: 0x2100400,
  	            0x170: 0x100401,
  	            0x180: 0x401,
  	            0x190: 0x2100401,
  	            0x1a0: 0x100400,
  	            0x1b0: 0x1,
  	            0x1c0: 0x0,
  	            0x1d0: 0x2100000,
  	            0x1e0: 0x2000001,
  	            0x1f0: 0x400,
  	            0x108: 0x100400,
  	            0x118: 0x2000401,
  	            0x128: 0x2100001,
  	            0x138: 0x1,
  	            0x148: 0x2000000,
  	            0x158: 0x100000,
  	            0x168: 0x401,
  	            0x178: 0x2100400,
  	            0x188: 0x2000001,
  	            0x198: 0x2100000,
  	            0x1a8: 0x0,
  	            0x1b8: 0x2100401,
  	            0x1c8: 0x100401,
  	            0x1d8: 0x400,
  	            0x1e8: 0x2000400,
  	            0x1f8: 0x100001
  	        },
  	        {
  	            0x0: 0x8000820,
  	            0x1: 0x20000,
  	            0x2: 0x8000000,
  	            0x3: 0x20,
  	            0x4: 0x20020,
  	            0x5: 0x8020820,
  	            0x6: 0x8020800,
  	            0x7: 0x800,
  	            0x8: 0x8020000,
  	            0x9: 0x8000800,
  	            0xa: 0x20800,
  	            0xb: 0x8020020,
  	            0xc: 0x820,
  	            0xd: 0x0,
  	            0xe: 0x8000020,
  	            0xf: 0x20820,
  	            0x80000000: 0x800,
  	            0x80000001: 0x8020820,
  	            0x80000002: 0x8000820,
  	            0x80000003: 0x8000000,
  	            0x80000004: 0x8020000,
  	            0x80000005: 0x20800,
  	            0x80000006: 0x20820,
  	            0x80000007: 0x20,
  	            0x80000008: 0x8000020,
  	            0x80000009: 0x820,
  	            0x8000000a: 0x20020,
  	            0x8000000b: 0x8020800,
  	            0x8000000c: 0x0,
  	            0x8000000d: 0x8020020,
  	            0x8000000e: 0x8000800,
  	            0x8000000f: 0x20000,
  	            0x10: 0x20820,
  	            0x11: 0x8020800,
  	            0x12: 0x20,
  	            0x13: 0x800,
  	            0x14: 0x8000800,
  	            0x15: 0x8000020,
  	            0x16: 0x8020020,
  	            0x17: 0x20000,
  	            0x18: 0x0,
  	            0x19: 0x20020,
  	            0x1a: 0x8020000,
  	            0x1b: 0x8000820,
  	            0x1c: 0x8020820,
  	            0x1d: 0x20800,
  	            0x1e: 0x820,
  	            0x1f: 0x8000000,
  	            0x80000010: 0x20000,
  	            0x80000011: 0x800,
  	            0x80000012: 0x8020020,
  	            0x80000013: 0x20820,
  	            0x80000014: 0x20,
  	            0x80000015: 0x8020000,
  	            0x80000016: 0x8000000,
  	            0x80000017: 0x8000820,
  	            0x80000018: 0x8020820,
  	            0x80000019: 0x8000020,
  	            0x8000001a: 0x8000800,
  	            0x8000001b: 0x0,
  	            0x8000001c: 0x20800,
  	            0x8000001d: 0x820,
  	            0x8000001e: 0x20020,
  	            0x8000001f: 0x8020800
  	        }
  	    ];
  
  	    // Masks that select the SBOX input
  	    var SBOX_MASK = [
  	        0xf8000001, 0x1f800000, 0x01f80000, 0x001f8000,
  	        0x0001f800, 0x00001f80, 0x000001f8, 0x8000001f
  	    ];
  
  	    /**
  	     * DES block cipher algorithm.
  	     */
  	    var DES = C_algo.DES = BlockCipher.extend({
  	        _doReset: function () {
  	            // Shortcuts
  	            var key = this._key;
  	            var keyWords = key.words;
  
  	            // Select 56 bits according to PC1
  	            var keyBits = [];
  	            for (var i = 0; i < 56; i++) {
  	                var keyBitPos = PC1[i] - 1;
  	                keyBits[i] = (keyWords[keyBitPos >>> 5] >>> (31 - keyBitPos % 32)) & 1;
  	            }
  
  	            // Assemble 16 subkeys
  	            var subKeys = this._subKeys = [];
  	            for (var nSubKey = 0; nSubKey < 16; nSubKey++) {
  	                // Create subkey
  	                var subKey = subKeys[nSubKey] = [];
  
  	                // Shortcut
  	                var bitShift = BIT_SHIFTS[nSubKey];
  
  	                // Select 48 bits according to PC2
  	                for (var i = 0; i < 24; i++) {
  	                    // Select from the left 28 key bits
  	                    subKey[(i / 6) | 0] |= keyBits[((PC2[i] - 1) + bitShift) % 28] << (31 - i % 6);
  
  	                    // Select from the right 28 key bits
  	                    subKey[4 + ((i / 6) | 0)] |= keyBits[28 + (((PC2[i + 24] - 1) + bitShift) % 28)] << (31 - i % 6);
  	                }
  
  	                // Since each subkey is applied to an expanded 32-bit input,
  	                // the subkey can be broken into 8 values scaled to 32-bits,
  	                // which allows the key to be used without expansion
  	                subKey[0] = (subKey[0] << 1) | (subKey[0] >>> 31);
  	                for (var i = 1; i < 7; i++) {
  	                    subKey[i] = subKey[i] >>> ((i - 1) * 4 + 3);
  	                }
  	                subKey[7] = (subKey[7] << 5) | (subKey[7] >>> 27);
  	            }
  
  	            // Compute inverse subkeys
  	            var invSubKeys = this._invSubKeys = [];
  	            for (var i = 0; i < 16; i++) {
  	                invSubKeys[i] = subKeys[15 - i];
  	            }
  	        },
  
  	        encryptBlock: function (M, offset) {
  	            this._doCryptBlock(M, offset, this._subKeys);
  	        },
  
  	        decryptBlock: function (M, offset) {
  	            this._doCryptBlock(M, offset, this._invSubKeys);
  	        },
  
  	        _doCryptBlock: function (M, offset, subKeys) {
  	            // Get input
  	            this._lBlock = M[offset];
  	            this._rBlock = M[offset + 1];
  
  	            // Initial permutation
  	            exchangeLR.call(this, 4,  0x0f0f0f0f);
  	            exchangeLR.call(this, 16, 0x0000ffff);
  	            exchangeRL.call(this, 2,  0x33333333);
  	            exchangeRL.call(this, 8,  0x00ff00ff);
  	            exchangeLR.call(this, 1,  0x55555555);
  
  	            // Rounds
  	            for (var round = 0; round < 16; round++) {
  	                // Shortcuts
  	                var subKey = subKeys[round];
  	                var lBlock = this._lBlock;
  	                var rBlock = this._rBlock;
  
  	                // Feistel function
  	                var f = 0;
  	                for (var i = 0; i < 8; i++) {
  	                    f |= SBOX_P[i][((rBlock ^ subKey[i]) & SBOX_MASK[i]) >>> 0];
  	                }
  	                this._lBlock = rBlock;
  	                this._rBlock = lBlock ^ f;
  	            }
  
  	            // Undo swap from last round
  	            var t = this._lBlock;
  	            this._lBlock = this._rBlock;
  	            this._rBlock = t;
  
  	            // Final permutation
  	            exchangeLR.call(this, 1,  0x55555555);
  	            exchangeRL.call(this, 8,  0x00ff00ff);
  	            exchangeRL.call(this, 2,  0x33333333);
  	            exchangeLR.call(this, 16, 0x0000ffff);
  	            exchangeLR.call(this, 4,  0x0f0f0f0f);
  
  	            // Set output
  	            M[offset] = this._lBlock;
  	            M[offset + 1] = this._rBlock;
  	        },
  
  	        keySize: 64/32,
  
  	        ivSize: 64/32,
  
  	        blockSize: 64/32
  	    });
  
  	    // Swap bits across the left and right words
  	    function exchangeLR(offset, mask) {
  	        var t = ((this._lBlock >>> offset) ^ this._rBlock) & mask;
  	        this._rBlock ^= t;
  	        this._lBlock ^= t << offset;
  	    }
  
  	    function exchangeRL(offset, mask) {
  	        var t = ((this._rBlock >>> offset) ^ this._lBlock) & mask;
  	        this._lBlock ^= t;
  	        this._rBlock ^= t << offset;
  	    }
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.DES.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.DES.decrypt(ciphertext, key, cfg);
  	     */
  	    C.DES = BlockCipher._createHelper(DES);
  
  	    /**
  	     * Triple-DES block cipher algorithm.
  	     */
  	    var TripleDES = C_algo.TripleDES = BlockCipher.extend({
  	        _doReset: function () {
  	            // Shortcuts
  	            var key = this._key;
  	            var keyWords = key.words;
  
  	            // Create DES instances
  	            this._des1 = DES.createEncryptor(WordArray.create(keyWords.slice(0, 2)));
  	            this._des2 = DES.createEncryptor(WordArray.create(keyWords.slice(2, 4)));
  	            this._des3 = DES.createEncryptor(WordArray.create(keyWords.slice(4, 6)));
  	        },
  
  	        encryptBlock: function (M, offset) {
  	            this._des1.encryptBlock(M, offset);
  	            this._des2.decryptBlock(M, offset);
  	            this._des3.encryptBlock(M, offset);
  	        },
  
  	        decryptBlock: function (M, offset) {
  	            this._des3.decryptBlock(M, offset);
  	            this._des2.encryptBlock(M, offset);
  	            this._des1.decryptBlock(M, offset);
  	        },
  
  	        keySize: 192/32,
  
  	        ivSize: 64/32,
  
  	        blockSize: 64/32
  	    });
  
  	    /**
  	     * Shortcut functions to the cipher's object interface.
  	     *
  	     * @example
  	     *
  	     *     var ciphertext = CryptoJS.TripleDES.encrypt(message, key, cfg);
  	     *     var plaintext  = CryptoJS.TripleDES.decrypt(ciphertext, key, cfg);
  	     */
  	    C.TripleDES = BlockCipher._createHelper(TripleDES);
  	}());
  
  
  	return CryptoJS.TripleDES;
  
  }));
  },{"./cipher-core":60,"./core":61,"./enc-base64":62,"./evpkdf":64,"./md5":69}],92:[function(require,module,exports){
  ;(function (root, factory) {
  	if (typeof exports === "object") {
  		// CommonJS
  		module.exports = exports = factory(require("./core"));
  	}
  	else if (typeof define === "function" && define.amd) {
  		// AMD
  		define(["./core"], factory);
  	}
  	else {
  		// Global (browser)
  		factory(root.CryptoJS);
  	}
  }(this, function (CryptoJS) {
  
  	(function (undefined) {
  	    // Shortcuts
  	    var C = CryptoJS;
  	    var C_lib = C.lib;
  	    var Base = C_lib.Base;
  	    var X32WordArray = C_lib.WordArray;
  
  	    /**
  	     * x64 namespace.
  	     */
  	    var C_x64 = C.x64 = {};
  
  	    /**
  	     * A 64-bit word.
  	     */
  	    var X64Word = C_x64.Word = Base.extend({
  	        /**
  	         * Initializes a newly created 64-bit word.
  	         *
  	         * @param {number} high The high 32 bits.
  	         * @param {number} low The low 32 bits.
  	         *
  	         * @example
  	         *
  	         *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
  	         */
  	        init: function (high, low) {
  	            this.high = high;
  	            this.low = low;
  	        }
  
  	        /**
  	         * Bitwise NOTs this word.
  	         *
  	         * @return {X64Word} A new x64-Word object after negating.
  	         *
  	         * @example
  	         *
  	         *     var negated = x64Word.not();
  	         */
  	        // not: function () {
  	            // var high = ~this.high;
  	            // var low = ~this.low;
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Bitwise ANDs this word with the passed word.
  	         *
  	         * @param {X64Word} word The x64-Word to AND with this word.
  	         *
  	         * @return {X64Word} A new x64-Word object after ANDing.
  	         *
  	         * @example
  	         *
  	         *     var anded = x64Word.and(anotherX64Word);
  	         */
  	        // and: function (word) {
  	            // var high = this.high & word.high;
  	            // var low = this.low & word.low;
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Bitwise ORs this word with the passed word.
  	         *
  	         * @param {X64Word} word The x64-Word to OR with this word.
  	         *
  	         * @return {X64Word} A new x64-Word object after ORing.
  	         *
  	         * @example
  	         *
  	         *     var ored = x64Word.or(anotherX64Word);
  	         */
  	        // or: function (word) {
  	            // var high = this.high | word.high;
  	            // var low = this.low | word.low;
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Bitwise XORs this word with the passed word.
  	         *
  	         * @param {X64Word} word The x64-Word to XOR with this word.
  	         *
  	         * @return {X64Word} A new x64-Word object after XORing.
  	         *
  	         * @example
  	         *
  	         *     var xored = x64Word.xor(anotherX64Word);
  	         */
  	        // xor: function (word) {
  	            // var high = this.high ^ word.high;
  	            // var low = this.low ^ word.low;
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Shifts this word n bits to the left.
  	         *
  	         * @param {number} n The number of bits to shift.
  	         *
  	         * @return {X64Word} A new x64-Word object after shifting.
  	         *
  	         * @example
  	         *
  	         *     var shifted = x64Word.shiftL(25);
  	         */
  	        // shiftL: function (n) {
  	            // if (n < 32) {
  	                // var high = (this.high << n) | (this.low >>> (32 - n));
  	                // var low = this.low << n;
  	            // } else {
  	                // var high = this.low << (n - 32);
  	                // var low = 0;
  	            // }
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Shifts this word n bits to the right.
  	         *
  	         * @param {number} n The number of bits to shift.
  	         *
  	         * @return {X64Word} A new x64-Word object after shifting.
  	         *
  	         * @example
  	         *
  	         *     var shifted = x64Word.shiftR(7);
  	         */
  	        // shiftR: function (n) {
  	            // if (n < 32) {
  	                // var low = (this.low >>> n) | (this.high << (32 - n));
  	                // var high = this.high >>> n;
  	            // } else {
  	                // var low = this.high >>> (n - 32);
  	                // var high = 0;
  	            // }
  
  	            // return X64Word.create(high, low);
  	        // },
  
  	        /**
  	         * Rotates this word n bits to the left.
  	         *
  	         * @param {number} n The number of bits to rotate.
  	         *
  	         * @return {X64Word} A new x64-Word object after rotating.
  	         *
  	         * @example
  	         *
  	         *     var rotated = x64Word.rotL(25);
  	         */
  	        // rotL: function (n) {
  	            // return this.shiftL(n).or(this.shiftR(64 - n));
  	        // },
  
  	        /**
  	         * Rotates this word n bits to the right.
  	         *
  	         * @param {number} n The number of bits to rotate.
  	         *
  	         * @return {X64Word} A new x64-Word object after rotating.
  	         *
  	         * @example
  	         *
  	         *     var rotated = x64Word.rotR(7);
  	         */
  	        // rotR: function (n) {
  	            // return this.shiftR(n).or(this.shiftL(64 - n));
  	        // },
  
  	        /**
  	         * Adds this word with the passed word.
  	         *
  	         * @param {X64Word} word The x64-Word to add with this word.
  	         *
  	         * @return {X64Word} A new x64-Word object after adding.
  	         *
  	         * @example
  	         *
  	         *     var added = x64Word.add(anotherX64Word);
  	         */
  	        // add: function (word) {
  	            // var low = (this.low + word.low) | 0;
  	            // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
  	            // var high = (this.high + word.high + carry) | 0;
  
  	            // return X64Word.create(high, low);
  	        // }
  	    });
  
  	    /**
  	     * An array of 64-bit words.
  	     *
  	     * @property {Array} words The array of CryptoJS.x64.Word objects.
  	     * @property {number} sigBytes The number of significant bytes in this word array.
  	     */
  	    var X64WordArray = C_x64.WordArray = Base.extend({
  	        /**
  	         * Initializes a newly created word array.
  	         *
  	         * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
  	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
  	         *
  	         * @example
  	         *
  	         *     var wordArray = CryptoJS.x64.WordArray.create();
  	         *
  	         *     var wordArray = CryptoJS.x64.WordArray.create([
  	         *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
  	         *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
  	         *     ]);
  	         *
  	         *     var wordArray = CryptoJS.x64.WordArray.create([
  	         *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
  	         *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
  	         *     ], 10);
  	         */
  	        init: function (words, sigBytes) {
  	            words = this.words = words || [];
  
  	            if (sigBytes != undefined) {
  	                this.sigBytes = sigBytes;
  	            } else {
  	                this.sigBytes = words.length * 8;
  	            }
  	        },
  
  	        /**
  	         * Converts this 64-bit word array to a 32-bit word array.
  	         *
  	         * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
  	         *
  	         * @example
  	         *
  	         *     var x32WordArray = x64WordArray.toX32();
  	         */
  	        toX32: function () {
  	            // Shortcuts
  	            var x64Words = this.words;
  	            var x64WordsLength = x64Words.length;
  
  	            // Convert
  	            var x32Words = [];
  	            for (var i = 0; i < x64WordsLength; i++) {
  	                var x64Word = x64Words[i];
  	                x32Words.push(x64Word.high);
  	                x32Words.push(x64Word.low);
  	            }
  
  	            return X32WordArray.create(x32Words, this.sigBytes);
  	        },
  
  	        /**
  	         * Creates a copy of this word array.
  	         *
  	         * @return {X64WordArray} The clone.
  	         *
  	         * @example
  	         *
  	         *     var clone = x64WordArray.clone();
  	         */
  	        clone: function () {
  	            var clone = Base.clone.call(this);
  
  	            // Clone "words" array
  	            var words = clone.words = this.words.slice(0);
  
  	            // Clone each X64Word object
  	            var wordsLength = words.length;
  	            for (var i = 0; i < wordsLength; i++) {
  	                words[i] = words[i].clone();
  	            }
  
  	            return clone;
  	        }
  	    });
  	}());
  
  
  	return CryptoJS;
  
  }));
  },{"./core":61}],93:[function(require,module,exports){
  // 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 objectCreate = Object.create || objectCreatePolyfill
  var objectKeys = Object.keys || objectKeysPolyfill
  var bind = Function.prototype.bind || functionBindPolyfill
  
  function EventEmitter() {
    if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
      this._events = objectCreate(null);
      this._eventsCount = 0;
    }
  
    this._maxListeners = this._maxListeners || undefined;
  }
  module.exports = EventEmitter;
  
  // Backwards-compat with node 0.10.x
  EventEmitter.EventEmitter = EventEmitter;
  
  EventEmitter.prototype._events = undefined;
  EventEmitter.prototype._maxListeners = undefined;
  
  // By default EventEmitters will print a warning if more than 10 listeners are
  // added to it. This is a useful default which helps finding memory leaks.
  var defaultMaxListeners = 10;
  
  var hasDefineProperty;
  try {
    var o = {};
    if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
    hasDefineProperty = o.x === 0;
  } catch (err) { hasDefineProperty = false }
  if (hasDefineProperty) {
    Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
      enumerable: true,
      get: function() {
        return defaultMaxListeners;
      },
      set: function(arg) {
        // check whether the input is a positive number (whose value is zero or
        // greater and not a NaN).
        if (typeof arg !== 'number' || arg < 0 || arg !== arg)
          throw new TypeError('"defaultMaxListeners" must be a positive number');
        defaultMaxListeners = arg;
      }
    });
  } else {
    EventEmitter.defaultMaxListeners = defaultMaxListeners;
  }
  
  // Obviously not all Emitters should be limited to 10. This function allows
  // that to be increased. Set to zero for unlimited.
  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
    if (typeof n !== 'number' || n < 0 || isNaN(n))
      throw new TypeError('"n" argument must be a positive number');
    this._maxListeners = n;
    return this;
  };
  
  function $getMaxListeners(that) {
    if (that._maxListeners === undefined)
      return EventEmitter.defaultMaxListeners;
    return that._maxListeners;
  }
  
  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
    return $getMaxListeners(this);
  };
  
  // These standalone emit* functions are used to optimize calling of event
  // handlers for fast cases because emit() itself often has a variable number of
  // arguments and can be deoptimized because of that. These functions always have
  // the same number of arguments and thus do not get deoptimized, so the code
  // inside them can execute faster.
  function emitNone(handler, isFn, self) {
    if (isFn)
      handler.call(self);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self);
    }
  }
  function emitOne(handler, isFn, self, arg1) {
    if (isFn)
      handler.call(self, arg1);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1);
    }
  }
  function emitTwo(handler, isFn, self, arg1, arg2) {
    if (isFn)
      handler.call(self, arg1, arg2);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1, arg2);
    }
  }
  function emitThree(handler, isFn, self, arg1, arg2, arg3) {
    if (isFn)
      handler.call(self, arg1, arg2, arg3);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].call(self, arg1, arg2, arg3);
    }
  }
  
  function emitMany(handler, isFn, self, args) {
    if (isFn)
      handler.apply(self, args);
    else {
      var len = handler.length;
      var listeners = arrayClone(handler, len);
      for (var i = 0; i < len; ++i)
        listeners[i].apply(self, args);
    }
  }
  
  EventEmitter.prototype.emit = function emit(type) {
    var er, handler, len, args, i, events;
    var doError = (type === 'error');
  
    events = this._events;
    if (events)
      doError = (doError && events.error == null);
    else if (!doError)
      return false;
  
    // If there is no 'error' event listener then throw.
    if (doError) {
      if (arguments.length > 1)
        er = arguments[1];
      if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      } else {
        // At least give some kind of context to the user
        var err = new Error('Unhandled "error" event. (' + er + ')');
        err.context = er;
        throw err;
      }
      return false;
    }
  
    handler = events[type];
  
    if (!handler)
      return false;
  
    var isFn = typeof handler === 'function';
    len = arguments.length;
    switch (len) {
        // fast cases
      case 1:
        emitNone(handler, isFn, this);
        break;
      case 2:
        emitOne(handler, isFn, this, arguments[1]);
        break;
      case 3:
        emitTwo(handler, isFn, this, arguments[1], arguments[2]);
        break;
      case 4:
        emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
        break;
        // slower
      default:
        args = new Array(len - 1);
        for (i = 1; i < len; i++)
          args[i - 1] = arguments[i];
        emitMany(handler, isFn, this, args);
    }
  
    return true;
  };
  
  function _addListener(target, type, listener, prepend) {
    var m;
    var events;
    var existing;
  
    if (typeof listener !== 'function')
      throw new TypeError('"listener" argument must be a function');
  
    events = target._events;
    if (!events) {
      events = target._events = objectCreate(null);
      target._eventsCount = 0;
    } else {
      // To avoid recursion in the case that type === "newListener"! Before
      // adding it to the listeners, first emit "newListener".
      if (events.newListener) {
        target.emit('newListener', type,
            listener.listener ? listener.listener : listener);
  
        // Re-assign `events` because a newListener handler could have caused the
        // this._events to be assigned to a new object
        events = target._events;
      }
      existing = events[type];
    }
  
    if (!existing) {
      // Optimize the case of one listener. Don't need the extra array object.
      existing = events[type] = listener;
      ++target._eventsCount;
    } else {
      if (typeof existing === 'function') {
        // Adding the second element, need to change to array.
        existing = events[type] =
            prepend ? [listener, existing] : [existing, listener];
      } else {
        // If we've already got an array, just append.
        if (prepend) {
          existing.unshift(listener);
        } else {
          existing.push(listener);
        }
      }
  
      // Check for listener leak
      if (!existing.warned) {
        m = $getMaxListeners(target);
        if (m && m > 0 && existing.length > m) {
          existing.warned = true;
          var w = new Error('Possible EventEmitter memory leak detected. ' +
              existing.length + ' "' + String(type) + '" listeners ' +
              'added. Use emitter.setMaxListeners() to ' +
              'increase limit.');
          w.name = 'MaxListenersExceededWarning';
          w.emitter = target;
          w.type = type;
          w.count = existing.length;
          if (typeof console === 'object' && console.warn) {
            console.warn('%s: %s', w.name, w.message);
          }
        }
      }
    }
  
    return target;
  }
  
  EventEmitter.prototype.addListener = function addListener(type, listener) {
    return _addListener(this, type, listener, false);
  };
  
  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
  
  EventEmitter.prototype.prependListener =
      function prependListener(type, listener) {
        return _addListener(this, type, listener, true);
      };
  
  function onceWrapper() {
    if (!this.fired) {
      this.target.removeListener(this.type, this.wrapFn);
      this.fired = true;
      switch (arguments.length) {
        case 0:
          return this.listener.call(this.target);
        case 1:
          return this.listener.call(this.target, arguments[0]);
        case 2:
          return this.listener.call(this.target, arguments[0], arguments[1]);
        case 3:
          return this.listener.call(this.target, arguments[0], arguments[1],
              arguments[2]);
        default:
          var args = new Array(arguments.length);
          for (var i = 0; i < args.length; ++i)
            args[i] = arguments[i];
          this.listener.apply(this.target, args);
      }
    }
  }
  
  function _onceWrap(target, type, listener) {
    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
    var wrapped = bind.call(onceWrapper, state);
    wrapped.listener = listener;
    state.wrapFn = wrapped;
    return wrapped;
  }
  
  EventEmitter.prototype.once = function once(type, listener) {
    if (typeof listener !== 'function')
      throw new TypeError('"listener" argument must be a function');
    this.on(type, _onceWrap(this, type, listener));
    return this;
  };
  
  EventEmitter.prototype.prependOnceListener =
      function prependOnceListener(type, listener) {
        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');
        this.prependListener(type, _onceWrap(this, type, listener));
        return this;
      };
  
  // Emits a 'removeListener' event if and only if the listener was removed.
  EventEmitter.prototype.removeListener =
      function removeListener(type, listener) {
        var list, events, position, i, originalListener;
  
        if (typeof listener !== 'function')
          throw new TypeError('"listener" argument must be a function');
  
        events = this._events;
        if (!events)
          return this;
  
        list = events[type];
        if (!list)
          return this;
  
        if (list === listener || list.listener === listener) {
          if (--this._eventsCount === 0)
            this._events = objectCreate(null);
          else {
            delete events[type];
            if (events.removeListener)
              this.emit('removeListener', type, list.listener || listener);
          }
        } else if (typeof list !== 'function') {
          position = -1;
  
          for (i = list.length - 1; i >= 0; i--) {
            if (list[i] === listener || list[i].listener === listener) {
              originalListener = list[i].listener;
              position = i;
              break;
            }
          }
  
          if (position < 0)
            return this;
  
          if (position === 0)
            list.shift();
          else
            spliceOne(list, position);
  
          if (list.length === 1)
            events[type] = list[0];
  
          if (events.removeListener)
            this.emit('removeListener', type, originalListener || listener);
        }
  
        return this;
      };
  
  EventEmitter.prototype.removeAllListeners =
      function removeAllListeners(type) {
        var listeners, events, i;
  
        events = this._events;
        if (!events)
          return this;
  
        // not listening for removeListener, no need to emit
        if (!events.removeListener) {
          if (arguments.length === 0) {
            this._events = objectCreate(null);
            this._eventsCount = 0;
          } else if (events[type]) {
            if (--this._eventsCount === 0)
              this._events = objectCreate(null);
            else
              delete events[type];
          }
          return this;
        }
  
        // emit removeListener for all listeners on all events
        if (arguments.length === 0) {
          var keys = objectKeys(events);
          var key;
          for (i = 0; i < keys.length; ++i) {
            key = keys[i];
            if (key === 'removeListener') continue;
            this.removeAllListeners(key);
          }
          this.removeAllListeners('removeListener');
          this._events = objectCreate(null);
          this._eventsCount = 0;
          return this;
        }
  
        listeners = events[type];
  
        if (typeof listeners === 'function') {
          this.removeListener(type, listeners);
        } else if (listeners) {
          // LIFO order
          for (i = listeners.length - 1; i >= 0; i--) {
            this.removeListener(type, listeners[i]);
          }
        }
  
        return this;
      };
  
  function _listeners(target, type, unwrap) {
    var events = target._events;
  
    if (!events)
      return [];
  
    var evlistener = events[type];
    if (!evlistener)
      return [];
  
    if (typeof evlistener === 'function')
      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
  
    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
  }
  
  EventEmitter.prototype.listeners = function listeners(type) {
    return _listeners(this, type, true);
  };
  
  EventEmitter.prototype.rawListeners = function rawListeners(type) {
    return _listeners(this, type, false);
  };
  
  EventEmitter.listenerCount = function(emitter, type) {
    if (typeof emitter.listenerCount === 'function') {
      return emitter.listenerCount(type);
    } else {
      return listenerCount.call(emitter, type);
    }
  };
  
  EventEmitter.prototype.listenerCount = listenerCount;
  function listenerCount(type) {
    var events = this._events;
  
    if (events) {
      var evlistener = events[type];
  
      if (typeof evlistener === 'function') {
        return 1;
      } else if (evlistener) {
        return evlistener.length;
      }
    }
  
    return 0;
  }
  
  EventEmitter.prototype.eventNames = function eventNames() {
    return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
  };
  
  // About 1.5x faster than the two-arg version of Array#splice().
  function spliceOne(list, index) {
    for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
      list[i] = list[k];
    list.pop();
  }
  
  function arrayClone(arr, n) {
    var copy = new Array(n);
    for (var i = 0; i < n; ++i)
      copy[i] = arr[i];
    return copy;
  }
  
  function unwrapListeners(arr) {
    var ret = new Array(arr.length);
    for (var i = 0; i < ret.length; ++i) {
      ret[i] = arr[i].listener || arr[i];
    }
    return ret;
  }
  
  function objectCreatePolyfill(proto) {
    var F = function() {};
    F.prototype = proto;
    return new F;
  }
  function objectKeysPolyfill(obj) {
    var keys = [];
    for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
      keys.push(k);
    }
    return k;
  }
  function functionBindPolyfill(context) {
    var fn = this;
    return function () {
      return fn.apply(context, arguments);
    };
  }
  
  },{}],94:[function(require,module,exports){
  var http = require('http')
  var url = require('url')
  
  var https = module.exports
  
  for (var key in http) {
    if (http.hasOwnProperty(key)) https[key] = http[key]
  }
  
  https.request = function (params, cb) {
    params = validateParams(params)
    return http.request.call(this, params, cb)
  }
  
  https.get = function (params, cb) {
    params = validateParams(params)
    return http.get.call(this, params, cb)
  }
  
  function validateParams (params) {
    if (typeof params === 'string') {
      params = url.parse(params)
    }
    if (!params.protocol) {
      params.protocol = 'https:'
    }
    if (params.protocol !== 'https:') {
      throw new Error('Protocol "' + params.protocol + '" not supported. Expected "https:"')
    }
    return params
  }
  
  },{"http":117,"url":123}],95:[function(require,module,exports){
  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
  }
  
  },{}],96:[function(require,module,exports){
  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.prototype = superCtor.prototype
      ctor.prototype = new TempCtor()
      ctor.prototype.constructor = ctor
    }
  }
  
  },{}],97:[function(require,module,exports){
  /*!
   * Determine if an object is a Buffer
   *
   * @author   Feross Aboukhadijeh <https://feross.org>
   * @license  MIT
   */
  
  // The _isBuffer check is for Safari 5-7 support, because it's missing
  // Object.prototype.constructor. Remove this eventually
  module.exports = function (obj) {
    return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
  }
  
  function isBuffer (obj) {
    return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
  }
  
  // For Node v0.10 support. Remove this eventually.
  function isSlowBuffer (obj) {
    return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
  }
  
  },{}],98:[function(require,module,exports){
  var toString = {}.toString;
  
  module.exports = Array.isArray || function (arr) {
    return toString.call(arr) == '[object Array]';
  };
  
  },{}],99:[function(require,module,exports){
  exports.endianness = function () { return 'LE' };
  
  exports.hostname = function () {
      if (typeof location !== 'undefined') {
          return location.hostname
      }
      else return '';
  };
  
  exports.loadavg = function () { return [] };
  
  exports.uptime = function () { return 0 };
  
  exports.freemem = function () {
      return Number.MAX_VALUE;
  };
  
  exports.totalmem = function () {
      return Number.MAX_VALUE;
  };
  
  exports.cpus = function () { return [] };
  
  exports.type = function () { return 'Browser' };
  
  exports.release = function () {
      if (typeof navigator !== 'undefined') {
          return navigator.appVersion;
      }
      return '';
  };
  
  exports.networkInterfaces
  = exports.getNetworkInterfaces
  = function () { return {} };
  
  exports.arch = function () { return 'javascript' };
  
  exports.platform = function () { return 'browser' };
  
  exports.tmpdir = exports.tmpDir = function () {
      return '/tmp';
  };
  
  exports.EOL = '\n';
  
  exports.homedir = function () {
  	return '/'
  };
  
  },{}],100:[function(require,module,exports){
  (function (process){
  'use strict';
  
  if (!process.version ||
      process.version.indexOf('v0.') === 0 ||
      process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
    module.exports = { nextTick: nextTick };
  } else {
    module.exports = process
  }
  
  function nextTick(fn, arg1, arg2, arg3) {
    if (typeof fn !== 'function') {
      throw new TypeError('"callback" argument must be a function');
    }
    var len = arguments.length;
    var args, i;
    switch (len) {
    case 0:
    case 1:
      return process.nextTick(fn);
    case 2:
      return process.nextTick(function afterTickOne() {
        fn.call(null, arg1);
      });
    case 3:
      return process.nextTick(function afterTickTwo() {
        fn.call(null, arg1, arg2);
      });
    case 4:
      return process.nextTick(function afterTickThree() {
        fn.call(null, arg1, arg2, arg3);
      });
    default:
      args = new Array(len - 1);
      i = 0;
      while (i < args.length) {
        args[i++] = arguments[i];
      }
      return process.nextTick(function afterTick() {
        fn.apply(null, args);
      });
    }
  }
  
  
  }).call(this,require('_process'))
  
  },{"_process":101}],101:[function(require,module,exports){
  // 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 defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  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 = runTimeout(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;
      runClearTimeout(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) {
          runTimeout(drainQueue);
      }
  };
  
  // 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.prependListener = noop;
  process.prependOnceListener = noop;
  
  process.listeners = function (name) { return [] }
  
  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; };
  
  },{}],102:[function(require,module,exports){
  (function (global){
  /*! https://mths.be/punycode v1.4.1 by @mathias */
  ;(function(root) {
  
  	/** Detect free variables */
  	var freeExports = typeof exports == 'object' && exports &&
  		!exports.nodeType && exports;
  	var freeModule = typeof module == 'object' && module &&
  		!module.nodeType && module;
  	var freeGlobal = typeof global == 'object' && global;
  	if (
  		freeGlobal.global === freeGlobal ||
  		freeGlobal.window === freeGlobal ||
  		freeGlobal.self === freeGlobal
  	) {
  		root = freeGlobal;
  	}
  
  	/**
  	 * The `punycode` object.
  	 * @name punycode
  	 * @type Object
  	 */
  	var punycode,
  
  	/** Highest positive signed 32-bit float value */
  	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
  
  	/** Bootstring parameters */
  	base = 36,
  	tMin = 1,
  	tMax = 26,
  	skew = 38,
  	damp = 700,
  	initialBias = 72,
  	initialN = 128, // 0x80
  	delimiter = '-', // '\x2D'
  
  	/** Regular expressions */
  	regexPunycode = /^xn--/,
  	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
  	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
  
  	/** Error messages */
  	errors = {
  		'overflow': 'Overflow: input needs wider integers to process',
  		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
  		'invalid-input': 'Invalid input'
  	},
  
  	/** Convenience shortcuts */
  	baseMinusTMin = base - tMin,
  	floor = Math.floor,
  	stringFromCharCode = String.fromCharCode,
  
  	/** Temporary variable */
  	key;
  
  	/*--------------------------------------------------------------------------*/
  
  	/**
  	 * A generic error utility function.
  	 * @private
  	 * @param {String} type The error type.
  	 * @returns {Error} Throws a `RangeError` with the applicable error message.
  	 */
  	function error(type) {
  		throw new RangeError(errors[type]);
  	}
  
  	/**
  	 * A generic `Array#map` utility function.
  	 * @private
  	 * @param {Array} array The array to iterate over.
  	 * @param {Function} callback The function that gets called for every array
  	 * item.
  	 * @returns {Array} A new array of values returned by the callback function.
  	 */
  	function map(array, fn) {
  		var length = array.length;
  		var result = [];
  		while (length--) {
  			result[length] = fn(array[length]);
  		}
  		return result;
  	}
  
  	/**
  	 * A simple `Array#map`-like wrapper to work with domain name strings or email
  	 * addresses.
  	 * @private
  	 * @param {String} domain The domain name or email address.
  	 * @param {Function} callback The function that gets called for every
  	 * character.
  	 * @returns {Array} A new string of characters returned by the callback
  	 * function.
  	 */
  	function mapDomain(string, fn) {
  		var parts = string.split('@');
  		var result = '';
  		if (parts.length > 1) {
  			// In email addresses, only the domain name should be punycoded. Leave
  			// the local part (i.e. everything up to `@`) intact.
  			result = parts[0] + '@';
  			string = parts[1];
  		}
  		// Avoid `split(regex)` for IE8 compatibility. See #17.
  		string = string.replace(regexSeparators, '\x2E');
  		var labels = string.split('.');
  		var encoded = map(labels, fn).join('.');
  		return result + encoded;
  	}
  
  	/**
  	 * Creates an array containing the numeric code points of each Unicode
  	 * character in the string. While JavaScript uses UCS-2 internally,
  	 * this function will convert a pair of surrogate halves (each of which
  	 * UCS-2 exposes as separate characters) into a single code point,
  	 * matching UTF-16.
  	 * @see `punycode.ucs2.encode`
  	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  	 * @memberOf punycode.ucs2
  	 * @name decode
  	 * @param {String} string The Unicode input string (UCS-2).
  	 * @returns {Array} The new array of code points.
  	 */
  	function ucs2decode(string) {
  		var output = [],
  		    counter = 0,
  		    length = string.length,
  		    value,
  		    extra;
  		while (counter < length) {
  			value = string.charCodeAt(counter++);
  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  				// high surrogate, and there is a next character
  				extra = string.charCodeAt(counter++);
  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  				} else {
  					// unmatched surrogate; only append this code unit, in case the next
  					// code unit is the high surrogate of a surrogate pair
  					output.push(value);
  					counter--;
  				}
  			} else {
  				output.push(value);
  			}
  		}
  		return output;
  	}
  
  	/**
  	 * Creates a string based on an array of numeric code points.
  	 * @see `punycode.ucs2.decode`
  	 * @memberOf punycode.ucs2
  	 * @name encode
  	 * @param {Array} codePoints The array of numeric code points.
  	 * @returns {String} The new Unicode string (UCS-2).
  	 */
  	function ucs2encode(array) {
  		return map(array, function(value) {
  			var output = '';
  			if (value > 0xFFFF) {
  				value -= 0x10000;
  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  				value = 0xDC00 | value & 0x3FF;
  			}
  			output += stringFromCharCode(value);
  			return output;
  		}).join('');
  	}
  
  	/**
  	 * Converts a basic code point into a digit/integer.
  	 * @see `digitToBasic()`
  	 * @private
  	 * @param {Number} codePoint The basic numeric code point value.
  	 * @returns {Number} The numeric value of a basic code point (for use in
  	 * representing integers) in the range `0` to `base - 1`, or `base` if
  	 * the code point does not represent a value.
  	 */
  	function basicToDigit(codePoint) {
  		if (codePoint - 48 < 10) {
  			return codePoint - 22;
  		}
  		if (codePoint - 65 < 26) {
  			return codePoint - 65;
  		}
  		if (codePoint - 97 < 26) {
  			return codePoint - 97;
  		}
  		return base;
  	}
  
  	/**
  	 * Converts a digit/integer into a basic code point.
  	 * @see `basicToDigit()`
  	 * @private
  	 * @param {Number} digit The numeric value of a basic code point.
  	 * @returns {Number} The basic code point whose value (when used for
  	 * representing integers) is `digit`, which needs to be in the range
  	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
  	 * used; else, the lowercase form is used. The behavior is undefined
  	 * if `flag` is non-zero and `digit` has no uppercase form.
  	 */
  	function digitToBasic(digit, flag) {
  		//  0..25 map to ASCII a..z or A..Z
  		// 26..35 map to ASCII 0..9
  		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
  	}
  
  	/**
  	 * Bias adaptation function as per section 3.4 of RFC 3492.
  	 * https://tools.ietf.org/html/rfc3492#section-3.4
  	 * @private
  	 */
  	function adapt(delta, numPoints, firstTime) {
  		var k = 0;
  		delta = firstTime ? floor(delta / damp) : delta >> 1;
  		delta += floor(delta / numPoints);
  		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
  			delta = floor(delta / baseMinusTMin);
  		}
  		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  	}
  
  	/**
  	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
  	 * symbols.
  	 * @memberOf punycode
  	 * @param {String} input The Punycode string of ASCII-only symbols.
  	 * @returns {String} The resulting string of Unicode symbols.
  	 */
  	function decode(input) {
  		// Don't use UCS-2
  		var output = [],
  		    inputLength = input.length,
  		    out,
  		    i = 0,
  		    n = initialN,
  		    bias = initialBias,
  		    basic,
  		    j,
  		    index,
  		    oldi,
  		    w,
  		    k,
  		    digit,
  		    t,
  		    /** Cached calculation results */
  		    baseMinusT;
  
  		// Handle the basic code points: let `basic` be the number of input code
  		// points before the last delimiter, or `0` if there is none, then copy
  		// the first basic code points to the output.
  
  		basic = input.lastIndexOf(delimiter);
  		if (basic < 0) {
  			basic = 0;
  		}
  
  		for (j = 0; j < basic; ++j) {
  			// if it's not a basic code point
  			if (input.charCodeAt(j) >= 0x80) {
  				error('not-basic');
  			}
  			output.push(input.charCodeAt(j));
  		}
  
  		// Main decoding loop: start just after the last delimiter if any basic code
  		// points were copied; start at the beginning otherwise.
  
  		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
  
  			// `index` is the index of the next character to be consumed.
  			// Decode a generalized variable-length integer into `delta`,
  			// which gets added to `i`. The overflow checking is easier
  			// if we increase `i` as we go, then subtract off its starting
  			// value at the end to obtain `delta`.
  			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
  
  				if (index >= inputLength) {
  					error('invalid-input');
  				}
  
  				digit = basicToDigit(input.charCodeAt(index++));
  
  				if (digit >= base || digit > floor((maxInt - i) / w)) {
  					error('overflow');
  				}
  
  				i += digit * w;
  				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  
  				if (digit < t) {
  					break;
  				}
  
  				baseMinusT = base - t;
  				if (w > floor(maxInt / baseMinusT)) {
  					error('overflow');
  				}
  
  				w *= baseMinusT;
  
  			}
  
  			out = output.length + 1;
  			bias = adapt(i - oldi, out, oldi == 0);
  
  			// `i` was supposed to wrap around from `out` to `0`,
  			// incrementing `n` each time, so we'll fix that now:
  			if (floor(i / out) > maxInt - n) {
  				error('overflow');
  			}
  
  			n += floor(i / out);
  			i %= out;
  
  			// Insert `n` at position `i` of the output
  			output.splice(i++, 0, n);
  
  		}
  
  		return ucs2encode(output);
  	}
  
  	/**
  	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
  	 * Punycode string of ASCII-only symbols.
  	 * @memberOf punycode
  	 * @param {String} input The string of Unicode symbols.
  	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
  	 */
  	function encode(input) {
  		var n,
  		    delta,
  		    handledCPCount,
  		    basicLength,
  		    bias,
  		    j,
  		    m,
  		    q,
  		    k,
  		    t,
  		    currentValue,
  		    output = [],
  		    /** `inputLength` will hold the number of code points in `input`. */
  		    inputLength,
  		    /** Cached calculation results */
  		    handledCPCountPlusOne,
  		    baseMinusT,
  		    qMinusT;
  
  		// Convert the input in UCS-2 to Unicode
  		input = ucs2decode(input);
  
  		// Cache the length
  		inputLength = input.length;
  
  		// Initialize the state
  		n = initialN;
  		delta = 0;
  		bias = initialBias;
  
  		// Handle the basic code points
  		for (j = 0; j < inputLength; ++j) {
  			currentValue = input[j];
  			if (currentValue < 0x80) {
  				output.push(stringFromCharCode(currentValue));
  			}
  		}
  
  		handledCPCount = basicLength = output.length;
  
  		// `handledCPCount` is the number of code points that have been handled;
  		// `basicLength` is the number of basic code points.
  
  		// Finish the basic string - if it is not empty - with a delimiter
  		if (basicLength) {
  			output.push(delimiter);
  		}
  
  		// Main encoding loop:
  		while (handledCPCount < inputLength) {
  
  			// All non-basic code points < n have been handled already. Find the next
  			// larger one:
  			for (m = maxInt, j = 0; j < inputLength; ++j) {
  				currentValue = input[j];
  				if (currentValue >= n && currentValue < m) {
  					m = currentValue;
  				}
  			}
  
  			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
  			// but guard against overflow
  			handledCPCountPlusOne = handledCPCount + 1;
  			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
  				error('overflow');
  			}
  
  			delta += (m - n) * handledCPCountPlusOne;
  			n = m;
  
  			for (j = 0; j < inputLength; ++j) {
  				currentValue = input[j];
  
  				if (currentValue < n && ++delta > maxInt) {
  					error('overflow');
  				}
  
  				if (currentValue == n) {
  					// Represent delta as a generalized variable-length integer
  					for (q = delta, k = base; /* no condition */; k += base) {
  						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
  						if (q < t) {
  							break;
  						}
  						qMinusT = q - t;
  						baseMinusT = base - t;
  						output.push(
  							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
  						);
  						q = floor(qMinusT / baseMinusT);
  					}
  
  					output.push(stringFromCharCode(digitToBasic(q, 0)));
  					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
  					delta = 0;
  					++handledCPCount;
  				}
  			}
  
  			++delta;
  			++n;
  
  		}
  		return output.join('');
  	}
  
  	/**
  	 * Converts a Punycode string representing a domain name or an email address
  	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
  	 * it doesn't matter if you call it on a string that has already been
  	 * converted to Unicode.
  	 * @memberOf punycode
  	 * @param {String} input The Punycoded domain name or email address to
  	 * convert to Unicode.
  	 * @returns {String} The Unicode representation of the given Punycode
  	 * string.
  	 */
  	function toUnicode(input) {
  		return mapDomain(input, function(string) {
  			return regexPunycode.test(string)
  				? decode(string.slice(4).toLowerCase())
  				: string;
  		});
  	}
  
  	/**
  	 * Converts a Unicode string representing a domain name or an email address to
  	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
  	 * i.e. it doesn't matter if you call it with a domain that's already in
  	 * ASCII.
  	 * @memberOf punycode
  	 * @param {String} input The domain name or email address to convert, as a
  	 * Unicode string.
  	 * @returns {String} The Punycode representation of the given domain name or
  	 * email address.
  	 */
  	function toASCII(input) {
  		return mapDomain(input, function(string) {
  			return regexNonASCII.test(string)
  				? 'xn--' + encode(string)
  				: string;
  		});
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	/** Define the public API */
  	punycode = {
  		/**
  		 * A string representing the current Punycode.js version number.
  		 * @memberOf punycode
  		 * @type String
  		 */
  		'version': '1.4.1',
  		/**
  		 * An object of methods to convert from JavaScript's internal character
  		 * representation (UCS-2) to Unicode code points, and back.
  		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
  		 * @memberOf punycode
  		 * @type Object
  		 */
  		'ucs2': {
  			'decode': ucs2decode,
  			'encode': ucs2encode
  		},
  		'decode': decode,
  		'encode': encode,
  		'toASCII': toASCII,
  		'toUnicode': toUnicode
  	};
  
  	/** Expose `punycode` */
  	// Some AMD build optimizers, like r.js, check for specific condition patterns
  	// like the following:
  	if (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define('punycode', function() {
  			return punycode;
  		});
  	} else if (freeExports && freeModule) {
  		if (module.exports == freeExports) {
  			// in Node.js, io.js, or RingoJS v0.8.0+
  			freeModule.exports = punycode;
  		} else {
  			// in Narwhal or RingoJS v0.7.0-
  			for (key in punycode) {
  				punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
  			}
  		}
  	} else {
  		// in Rhino or a web browser
  		root.punycode = punycode;
  	}
  
  }(this));
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{}],103:[function(require,module,exports){
  // 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.
  
  'use strict';
  
  // If obj.hasOwnProperty has been overridden, then calling
  // obj.hasOwnProperty(prop) will break.
  // See: https://github.com/joyent/node/issues/1707
  function hasOwnProperty(obj, prop) {
    return Object.prototype.hasOwnProperty.call(obj, prop);
  }
  
  module.exports = function(qs, sep, eq, options) {
    sep = sep || '&';
    eq = eq || '=';
    var obj = {};
  
    if (typeof qs !== 'string' || qs.length === 0) {
      return obj;
    }
  
    var regexp = /\+/g;
    qs = qs.split(sep);
  
    var maxKeys = 1000;
    if (options && typeof options.maxKeys === 'number') {
      maxKeys = options.maxKeys;
    }
  
    var len = qs.length;
    // maxKeys <= 0 means that we should not limit keys count
    if (maxKeys > 0 && len > maxKeys) {
      len = maxKeys;
    }
  
    for (var i = 0; i < len; ++i) {
      var x = qs[i].replace(regexp, '%20'),
          idx = x.indexOf(eq),
          kstr, vstr, k, v;
  
      if (idx >= 0) {
        kstr = x.substr(0, idx);
        vstr = x.substr(idx + 1);
      } else {
        kstr = x;
        vstr = '';
      }
  
      k = decodeURIComponent(kstr);
      v = decodeURIComponent(vstr);
  
      if (!hasOwnProperty(obj, k)) {
        obj[k] = v;
      } else if (isArray(obj[k])) {
        obj[k].push(v);
      } else {
        obj[k] = [obj[k], v];
      }
    }
  
    return obj;
  };
  
  var isArray = Array.isArray || function (xs) {
    return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  },{}],104:[function(require,module,exports){
  // 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.
  
  'use strict';
  
  var stringifyPrimitive = function(v) {
    switch (typeof v) {
      case 'string':
        return v;
  
      case 'boolean':
        return v ? 'true' : 'false';
  
      case 'number':
        return isFinite(v) ? v : '';
  
      default:
        return '';
    }
  };
  
  module.exports = function(obj, sep, eq, name) {
    sep = sep || '&';
    eq = eq || '=';
    if (obj === null) {
      obj = undefined;
    }
  
    if (typeof obj === 'object') {
      return map(objectKeys(obj), function(k) {
        var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
        if (isArray(obj[k])) {
          return map(obj[k], function(v) {
            return ks + encodeURIComponent(stringifyPrimitive(v));
          }).join(sep);
        } else {
          return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
        }
      }).join(sep);
  
    }
  
    if (!name) return '';
    return encodeURIComponent(stringifyPrimitive(name)) + eq +
           encodeURIComponent(stringifyPrimitive(obj));
  };
  
  var isArray = Array.isArray || function (xs) {
    return Object.prototype.toString.call(xs) === '[object Array]';
  };
  
  function map (xs, f) {
    if (xs.map) return xs.map(f);
    var res = [];
    for (var i = 0; i < xs.length; i++) {
      res.push(f(xs[i], i));
    }
    return res;
  }
  
  var objectKeys = Object.keys || function (obj) {
    var res = [];
    for (var key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
    }
    return res;
  };
  
  },{}],105:[function(require,module,exports){
  'use strict';
  
  exports.decode = exports.parse = require('./decode');
  exports.encode = exports.stringify = require('./encode');
  
  },{"./decode":103,"./encode":104}],106:[function(require,module,exports){
  // 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.
  
  // a duplex stream is just a stream that is both readable and writable.
  // Since JS doesn't have multiple prototypal inheritance, this class
  // prototypally inherits from Readable, and then parasitically from
  // Writable.
  
  'use strict';
  
  /*<replacement>*/
  
  var pna = require('process-nextick-args');
  /*</replacement>*/
  
  /*<replacement>*/
  var objectKeys = Object.keys || function (obj) {
    var keys = [];
    for (var key in obj) {
      keys.push(key);
    }return keys;
  };
  /*</replacement>*/
  
  module.exports = Duplex;
  
  /*<replacement>*/
  var util = require('core-util-is');
  util.inherits = require('inherits');
  /*</replacement>*/
  
  var Readable = require('./_stream_readable');
  var Writable = require('./_stream_writable');
  
  util.inherits(Duplex, Readable);
  
  {
    // avoid scope creep, the keys array can then be collected
    var keys = objectKeys(Writable.prototype);
    for (var v = 0; v < keys.length; v++) {
      var method = keys[v];
      if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
    }
  }
  
  function Duplex(options) {
    if (!(this instanceof Duplex)) return new Duplex(options);
  
    Readable.call(this, options);
    Writable.call(this, options);
  
    if (options && options.readable === false) this.readable = false;
  
    if (options && options.writable === false) this.writable = false;
  
    this.allowHalfOpen = true;
    if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
  
    this.once('end', onend);
  }
  
  Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._writableState.highWaterMark;
    }
  });
  
  // the no-half-open enforcer
  function onend() {
    // if we allow half-open state, or if the writable side ended,
    // then we're ok.
    if (this.allowHalfOpen || this._writableState.ended) return;
  
    // no more data can be written.
    // But allow more writes to happen in this tick.
    pna.nextTick(onEndNT, this);
  }
  
  function onEndNT(self) {
    self.end();
  }
  
  Object.defineProperty(Duplex.prototype, 'destroyed', {
    get: function () {
      if (this._readableState === undefined || this._writableState === undefined) {
        return false;
      }
      return this._readableState.destroyed && this._writableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (this._readableState === undefined || this._writableState === undefined) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._readableState.destroyed = value;
      this._writableState.destroyed = value;
    }
  });
  
  Duplex.prototype._destroy = function (err, cb) {
    this.push(null);
    this.end();
  
    pna.nextTick(cb, err);
  };
  },{"./_stream_readable":108,"./_stream_writable":110,"core-util-is":58,"inherits":96,"process-nextick-args":100}],107:[function(require,module,exports){
  // 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.
  
  // a passthrough stream.
  // basically just the most minimal sort of Transform stream.
  // Every written chunk gets output as-is.
  
  'use strict';
  
  module.exports = PassThrough;
  
  var Transform = require('./_stream_transform');
  
  /*<replacement>*/
  var util = require('core-util-is');
  util.inherits = require('inherits');
  /*</replacement>*/
  
  util.inherits(PassThrough, Transform);
  
  function PassThrough(options) {
    if (!(this instanceof PassThrough)) return new PassThrough(options);
  
    Transform.call(this, options);
  }
  
  PassThrough.prototype._transform = function (chunk, encoding, cb) {
    cb(null, chunk);
  };
  },{"./_stream_transform":109,"core-util-is":58,"inherits":96}],108:[function(require,module,exports){
  (function (process,global){
  // 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.
  
  'use strict';
  
  /*<replacement>*/
  
  var pna = require('process-nextick-args');
  /*</replacement>*/
  
  module.exports = Readable;
  
  /*<replacement>*/
  var isArray = require('isarray');
  /*</replacement>*/
  
  /*<replacement>*/
  var Duplex;
  /*</replacement>*/
  
  Readable.ReadableState = ReadableState;
  
  /*<replacement>*/
  var EE = require('events').EventEmitter;
  
  var EElistenerCount = function (emitter, type) {
    return emitter.listeners(type).length;
  };
  /*</replacement>*/
  
  /*<replacement>*/
  var Stream = require('./internal/streams/stream');
  /*</replacement>*/
  
  /*<replacement>*/
  
  var Buffer = require('safe-buffer').Buffer;
  var OurUint8Array = global.Uint8Array || function () {};
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  
  /*</replacement>*/
  
  /*<replacement>*/
  var util = require('core-util-is');
  util.inherits = require('inherits');
  /*</replacement>*/
  
  /*<replacement>*/
  var debugUtil = require('util');
  var debug = void 0;
  if (debugUtil && debugUtil.debuglog) {
    debug = debugUtil.debuglog('stream');
  } else {
    debug = function () {};
  }
  /*</replacement>*/
  
  var BufferList = require('./internal/streams/BufferList');
  var destroyImpl = require('./internal/streams/destroy');
  var StringDecoder;
  
  util.inherits(Readable, Stream);
  
  var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
  
  function prependListener(emitter, event, fn) {
    // Sadly this is not cacheable as some libraries bundle their own
    // event emitter implementation with them.
    if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
  
    // This is a hack to make sure that our error handler is attached before any
    // userland ones.  NEVER DO THIS. This is here only because this code needs
    // to continue to work with older versions of Node.js that do not include
    // the prependListener() method. The goal is to eventually remove this hack.
    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
  }
  
  function ReadableState(options, stream) {
    Duplex = Duplex || require('./_stream_duplex');
  
    options = options || {};
  
    // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream.
    // These options can be provided separately as readableXXX and writableXXX.
    var isDuplex = stream instanceof Duplex;
  
    // object stream flag. Used to make read(n) ignore n and to
    // make all the buffer merging and length checks go away
    this.objectMode = !!options.objectMode;
  
    if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
  
    // the point at which it stops calling _read() to fill the buffer
    // Note: 0 is a valid value, means "don't call _read preemptively ever"
    var hwm = options.highWaterMark;
    var readableHwm = options.readableHighWaterMark;
    var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
    if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
  
    // cast to ints.
    this.highWaterMark = Math.floor(this.highWaterMark);
  
    // A linked list is used to store data chunks instead of an array because the
    // linked list can remove elements from the beginning faster than
    // array.shift()
    this.buffer = new BufferList();
    this.length = 0;
    this.pipes = null;
    this.pipesCount = 0;
    this.flowing = null;
    this.ended = false;
    this.endEmitted = false;
    this.reading = false;
  
    // a flag to be able to tell if the event 'readable'/'data' is emitted
    // immediately, or on a later tick.  We set this to true at first, because
    // any actions that shouldn't happen until "later" should generally also
    // not happen before the first read call.
    this.sync = true;
  
    // whenever we return null, then we set a flag to say
    // that we're awaiting a 'readable' event emission.
    this.needReadable = false;
    this.emittedReadable = false;
    this.readableListening = false;
    this.resumeScheduled = false;
  
    // has it been destroyed
    this.destroyed = false;
  
    // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
    this.defaultEncoding = options.defaultEncoding || 'utf8';
  
    // the number of writers that are awaiting a drain event in .pipe()s
    this.awaitDrain = 0;
  
    // if true, a maybeReadMore has been scheduled
    this.readingMore = false;
  
    this.decoder = null;
    this.encoding = null;
    if (options.encoding) {
      if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
      this.decoder = new StringDecoder(options.encoding);
      this.encoding = options.encoding;
    }
  }
  
  function Readable(options) {
    Duplex = Duplex || require('./_stream_duplex');
  
    if (!(this instanceof Readable)) return new Readable(options);
  
    this._readableState = new ReadableState(options, this);
  
    // legacy
    this.readable = true;
  
    if (options) {
      if (typeof options.read === 'function') this._read = options.read;
  
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
    }
  
    Stream.call(this);
  }
  
  Object.defineProperty(Readable.prototype, 'destroyed', {
    get: function () {
      if (this._readableState === undefined) {
        return false;
      }
      return this._readableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._readableState) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._readableState.destroyed = value;
    }
  });
  
  Readable.prototype.destroy = destroyImpl.destroy;
  Readable.prototype._undestroy = destroyImpl.undestroy;
  Readable.prototype._destroy = function (err, cb) {
    this.push(null);
    cb(err);
  };
  
  // Manually shove something into the read() buffer.
  // This returns true if the highWaterMark has not been hit yet,
  // similar to how Writable.write() returns true if you should
  // write() some more.
  Readable.prototype.push = function (chunk, encoding) {
    var state = this._readableState;
    var skipChunkCheck;
  
    if (!state.objectMode) {
      if (typeof chunk === 'string') {
        encoding = encoding || state.defaultEncoding;
        if (encoding !== state.encoding) {
          chunk = Buffer.from(chunk, encoding);
          encoding = '';
        }
        skipChunkCheck = true;
      }
    } else {
      skipChunkCheck = true;
    }
  
    return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
  };
  
  // Unshift should *always* be something directly out of read()
  Readable.prototype.unshift = function (chunk) {
    return readableAddChunk(this, chunk, null, true, false);
  };
  
  function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
    var state = stream._readableState;
    if (chunk === null) {
      state.reading = false;
      onEofChunk(stream, state);
    } else {
      var er;
      if (!skipChunkCheck) er = chunkInvalid(state, chunk);
      if (er) {
        stream.emit('error', er);
      } else if (state.objectMode || chunk && chunk.length > 0) {
        if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
  
        if (addToFront) {
          if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
        } else if (state.ended) {
          stream.emit('error', new Error('stream.push() after EOF'));
        } else {
          state.reading = false;
          if (state.decoder && !encoding) {
            chunk = state.decoder.write(chunk);
            if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
          } else {
            addChunk(stream, state, chunk, false);
          }
        }
      } else if (!addToFront) {
        state.reading = false;
      }
    }
  
    return needMoreData(state);
  }
  
  function addChunk(stream, state, chunk, addToFront) {
    if (state.flowing && state.length === 0 && !state.sync) {
      stream.emit('data', chunk);
      stream.read(0);
    } else {
      // update the buffer info.
      state.length += state.objectMode ? 1 : chunk.length;
      if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
  
      if (state.needReadable) emitReadable(stream);
    }
    maybeReadMore(stream, state);
  }
  
  function chunkInvalid(state, chunk) {
    var er;
    if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
      er = new TypeError('Invalid non-string/buffer chunk');
    }
    return er;
  }
  
  // if it's past the high water mark, we can push in some more.
  // Also, if we have no data yet, we can stand some
  // more bytes.  This is to work around cases where hwm=0,
  // such as the repl.  Also, if the push() triggered a
  // readable event, and the user called read(largeNumber) such that
  // needReadable was set, then we ought to push more, so that another
  // 'readable' event will be triggered.
  function needMoreData(state) {
    return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
  }
  
  Readable.prototype.isPaused = function () {
    return this._readableState.flowing === false;
  };
  
  // backwards compatibility.
  Readable.prototype.setEncoding = function (enc) {
    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
    this._readableState.decoder = new StringDecoder(enc);
    this._readableState.encoding = enc;
    return this;
  };
  
  // Don't raise the hwm > 8MB
  var MAX_HWM = 0x800000;
  function computeNewHighWaterMark(n) {
    if (n >= MAX_HWM) {
      n = MAX_HWM;
    } else {
      // Get the next highest power of 2 to prevent increasing hwm excessively in
      // tiny amounts
      n--;
      n |= n >>> 1;
      n |= n >>> 2;
      n |= n >>> 4;
      n |= n >>> 8;
      n |= n >>> 16;
      n++;
    }
    return n;
  }
  
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function howMuchToRead(n, state) {
    if (n <= 0 || state.length === 0 && state.ended) return 0;
    if (state.objectMode) return 1;
    if (n !== n) {
      // Only flow one buffer at a time
      if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
    }
    // If we're asking for more than the current hwm, then raise the hwm.
    if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
    if (n <= state.length) return n;
    // Don't have enough
    if (!state.ended) {
      state.needReadable = true;
      return 0;
    }
    return state.length;
  }
  
  // you can override either this method, or the async _read(n) below.
  Readable.prototype.read = function (n) {
    debug('read', n);
    n = parseInt(n, 10);
    var state = this._readableState;
    var nOrig = n;
  
    if (n !== 0) state.emittedReadable = false;
  
    // if we're doing read(0) to trigger a readable event, but we
    // already have a bunch of data in the buffer, then just trigger
    // the 'readable' event and move on.
    if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
      debug('read: emitReadable', state.length, state.ended);
      if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
      return null;
    }
  
    n = howMuchToRead(n, state);
  
    // if we've ended, and we're now clear, then finish it up.
    if (n === 0 && state.ended) {
      if (state.length === 0) endReadable(this);
      return null;
    }
  
    // All the actual chunk generation logic needs to be
    // *below* the call to _read.  The reason is that in certain
    // synthetic stream cases, such as passthrough streams, _read
    // may be a completely synchronous operation which may change
    // the state of the read buffer, providing enough data when
    // before there was *not* enough.
    //
    // So, the steps are:
    // 1. Figure out what the state of things will be after we do
    // a read from the buffer.
    //
    // 2. If that resulting state will trigger a _read, then call _read.
    // Note that this may be asynchronous, or synchronous.  Yes, it is
    // deeply ugly to write APIs this way, but that still doesn't mean
    // that the Readable class should behave improperly, as streams are
    // designed to be sync/async agnostic.
    // Take note if the _read call is sync or async (ie, if the read call
    // has returned yet), so that we know whether or not it's safe to emit
    // 'readable' etc.
    //
    // 3. Actually pull the requested chunks out of the buffer and return.
  
    // if we need a readable event, then we need to do some reading.
    var doRead = state.needReadable;
    debug('need readable', doRead);
  
    // if we currently have less than the highWaterMark, then also read some
    if (state.length === 0 || state.length - n < state.highWaterMark) {
      doRead = true;
      debug('length less than watermark', doRead);
    }
  
    // however, if we've ended, then there's no point, and if we're already
    // reading, then it's unnecessary.
    if (state.ended || state.reading) {
      doRead = false;
      debug('reading or ended', doRead);
    } else if (doRead) {
      debug('do read');
      state.reading = true;
      state.sync = true;
      // if the length is currently zero, then we *need* a readable event.
      if (state.length === 0) state.needReadable = true;
      // call internal read method
      this._read(state.highWaterMark);
      state.sync = false;
      // If _read pushed data synchronously, then `reading` will be false,
      // and we need to re-evaluate how much data we can return to the user.
      if (!state.reading) n = howMuchToRead(nOrig, state);
    }
  
    var ret;
    if (n > 0) ret = fromList(n, state);else ret = null;
  
    if (ret === null) {
      state.needReadable = true;
      n = 0;
    } else {
      state.length -= n;
    }
  
    if (state.length === 0) {
      // If we have nothing in the buffer, then we want to know
      // as soon as we *do* get something into the buffer.
      if (!state.ended) state.needReadable = true;
  
      // If we tried to read() past the EOF, then emit end on the next tick.
      if (nOrig !== n && state.ended) endReadable(this);
    }
  
    if (ret !== null) this.emit('data', ret);
  
    return ret;
  };
  
  function onEofChunk(stream, state) {
    if (state.ended) return;
    if (state.decoder) {
      var chunk = state.decoder.end();
      if (chunk && chunk.length) {
        state.buffer.push(chunk);
        state.length += state.objectMode ? 1 : chunk.length;
      }
    }
    state.ended = true;
  
    // emit 'readable' now to make sure it gets picked up.
    emitReadable(stream);
  }
  
  // Don't emit readable right away in sync mode, because this can trigger
  // another read() call => stack overflow.  This way, it might trigger
  // a nextTick recursion warning, but that's not so bad.
  function emitReadable(stream) {
    var state = stream._readableState;
    state.needReadable = false;
    if (!state.emittedReadable) {
      debug('emitReadable', state.flowing);
      state.emittedReadable = true;
      if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
    }
  }
  
  function emitReadable_(stream) {
    debug('emit readable');
    stream.emit('readable');
    flow(stream);
  }
  
  // at this point, the user has presumably seen the 'readable' event,
  // and called read() to consume some data.  that may have triggered
  // in turn another _read(n) call, in which case reading = true if
  // it's in progress.
  // However, if we're not ended, or reading, and the length < hwm,
  // then go ahead and try to read some more preemptively.
  function maybeReadMore(stream, state) {
    if (!state.readingMore) {
      state.readingMore = true;
      pna.nextTick(maybeReadMore_, stream, state);
    }
  }
  
  function maybeReadMore_(stream, state) {
    var len = state.length;
    while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
      debug('maybeReadMore read 0');
      stream.read(0);
      if (len === state.length)
        // didn't get any data, stop spinning.
        break;else len = state.length;
    }
    state.readingMore = false;
  }
  
  // abstract method.  to be overridden in specific implementation classes.
  // call cb(er, data) where data is <= n in length.
  // for virtual (non-string, non-buffer) streams, "length" is somewhat
  // arbitrary, and perhaps not very meaningful.
  Readable.prototype._read = function (n) {
    this.emit('error', new Error('_read() is not implemented'));
  };
  
  Readable.prototype.pipe = function (dest, pipeOpts) {
    var src = this;
    var state = this._readableState;
  
    switch (state.pipesCount) {
      case 0:
        state.pipes = dest;
        break;
      case 1:
        state.pipes = [state.pipes, dest];
        break;
      default:
        state.pipes.push(dest);
        break;
    }
    state.pipesCount += 1;
    debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
  
    var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
  
    var endFn = doEnd ? onend : unpipe;
    if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
  
    dest.on('unpipe', onunpipe);
    function onunpipe(readable, unpipeInfo) {
      debug('onunpipe');
      if (readable === src) {
        if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
          unpipeInfo.hasUnpiped = true;
          cleanup();
        }
      }
    }
  
    function onend() {
      debug('onend');
      dest.end();
    }
  
    // when the dest drains, it reduces the awaitDrain counter
    // on the source.  This would be more elegant with a .once()
    // handler in flow(), but adding and removing repeatedly is
    // too slow.
    var ondrain = pipeOnDrain(src);
    dest.on('drain', ondrain);
  
    var cleanedUp = false;
    function cleanup() {
      debug('cleanup');
      // cleanup event handlers once the pipe is broken
      dest.removeListener('close', onclose);
      dest.removeListener('finish', onfinish);
      dest.removeListener('drain', ondrain);
      dest.removeListener('error', onerror);
      dest.removeListener('unpipe', onunpipe);
      src.removeListener('end', onend);
      src.removeListener('end', unpipe);
      src.removeListener('data', ondata);
  
      cleanedUp = true;
  
      // if the reader is waiting for a drain event from this
      // specific writer, then it would cause it to never start
      // flowing again.
      // So, if this is awaiting a drain, then we just call it now.
      // If we don't know, then assume that we are waiting for one.
      if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
    }
  
    // If the user pushes more data while we're writing to dest then we'll end up
    // in ondata again. However, we only want to increase awaitDrain once because
    // dest will only emit one 'drain' event for the multiple writes.
    // => Introduce a guard on increasing awaitDrain.
    var increasedAwaitDrain = false;
    src.on('data', ondata);
    function ondata(chunk) {
      debug('ondata');
      increasedAwaitDrain = false;
      var ret = dest.write(chunk);
      if (false === ret && !increasedAwaitDrain) {
        // If the user unpiped during `dest.write()`, it is possible
        // to get stuck in a permanently paused state if that write
        // also returned false.
        // => Check whether `dest` is still a piping destination.
        if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
          debug('false write response, pause', src._readableState.awaitDrain);
          src._readableState.awaitDrain++;
          increasedAwaitDrain = true;
        }
        src.pause();
      }
    }
  
    // if the dest has an error, then stop piping into it.
    // however, don't suppress the throwing behavior for this.
    function onerror(er) {
      debug('onerror', er);
      unpipe();
      dest.removeListener('error', onerror);
      if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
    }
  
    // Make sure our error handler is attached before userland ones.
    prependListener(dest, 'error', onerror);
  
    // Both close and finish should trigger unpipe, but only once.
    function onclose() {
      dest.removeListener('finish', onfinish);
      unpipe();
    }
    dest.once('close', onclose);
    function onfinish() {
      debug('onfinish');
      dest.removeListener('close', onclose);
      unpipe();
    }
    dest.once('finish', onfinish);
  
    function unpipe() {
      debug('unpipe');
      src.unpipe(dest);
    }
  
    // tell the dest that it's being piped to
    dest.emit('pipe', src);
  
    // start the flow if it hasn't been started already.
    if (!state.flowing) {
      debug('pipe resume');
      src.resume();
    }
  
    return dest;
  };
  
  function pipeOnDrain(src) {
    return function () {
      var state = src._readableState;
      debug('pipeOnDrain', state.awaitDrain);
      if (state.awaitDrain) state.awaitDrain--;
      if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
        state.flowing = true;
        flow(src);
      }
    };
  }
  
  Readable.prototype.unpipe = function (dest) {
    var state = this._readableState;
    var unpipeInfo = { hasUnpiped: false };
  
    // if we're not piping anywhere, then do nothing.
    if (state.pipesCount === 0) return this;
  
    // just one destination.  most common case.
    if (state.pipesCount === 1) {
      // passed in one, but it's not the right one.
      if (dest && dest !== state.pipes) return this;
  
      if (!dest) dest = state.pipes;
  
      // got a match.
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
      if (dest) dest.emit('unpipe', this, unpipeInfo);
      return this;
    }
  
    // slow case. multiple pipe destinations.
  
    if (!dest) {
      // remove all.
      var dests = state.pipes;
      var len = state.pipesCount;
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
  
      for (var i = 0; i < len; i++) {
        dests[i].emit('unpipe', this, unpipeInfo);
      }return this;
    }
  
    // try to find the right one.
    var index = indexOf(state.pipes, dest);
    if (index === -1) return this;
  
    state.pipes.splice(index, 1);
    state.pipesCount -= 1;
    if (state.pipesCount === 1) state.pipes = state.pipes[0];
  
    dest.emit('unpipe', this, unpipeInfo);
  
    return this;
  };
  
  // set up data events if they are asked for
  // Ensure readable listeners eventually get something
  Readable.prototype.on = function (ev, fn) {
    var res = Stream.prototype.on.call(this, ev, fn);
  
    if (ev === 'data') {
      // Start flowing on next tick if stream isn't explicitly paused
      if (this._readableState.flowing !== false) this.resume();
    } else if (ev === 'readable') {
      var state = this._readableState;
      if (!state.endEmitted && !state.readableListening) {
        state.readableListening = state.needReadable = true;
        state.emittedReadable = false;
        if (!state.reading) {
          pna.nextTick(nReadingNextTick, this);
        } else if (state.length) {
          emitReadable(this);
        }
      }
    }
  
    return res;
  };
  Readable.prototype.addListener = Readable.prototype.on;
  
  function nReadingNextTick(self) {
    debug('readable nexttick read 0');
    self.read(0);
  }
  
  // pause() and resume() are remnants of the legacy readable stream API
  // If the user uses them, then switch into old mode.
  Readable.prototype.resume = function () {
    var state = this._readableState;
    if (!state.flowing) {
      debug('resume');
      state.flowing = true;
      resume(this, state);
    }
    return this;
  };
  
  function resume(stream, state) {
    if (!state.resumeScheduled) {
      state.resumeScheduled = true;
      pna.nextTick(resume_, stream, state);
    }
  }
  
  function resume_(stream, state) {
    if (!state.reading) {
      debug('resume read 0');
      stream.read(0);
    }
  
    state.resumeScheduled = false;
    state.awaitDrain = 0;
    stream.emit('resume');
    flow(stream);
    if (state.flowing && !state.reading) stream.read(0);
  }
  
  Readable.prototype.pause = function () {
    debug('call pause flowing=%j', this._readableState.flowing);
    if (false !== this._readableState.flowing) {
      debug('pause');
      this._readableState.flowing = false;
      this.emit('pause');
    }
    return this;
  };
  
  function flow(stream) {
    var state = stream._readableState;
    debug('flow', state.flowing);
    while (state.flowing && stream.read() !== null) {}
  }
  
  // wrap an old-style stream as the async data source.
  // This is *not* part of the readable stream interface.
  // It is an ugly unfortunate mess of history.
  Readable.prototype.wrap = function (stream) {
    var _this = this;
  
    var state = this._readableState;
    var paused = false;
  
    stream.on('end', function () {
      debug('wrapped end');
      if (state.decoder && !state.ended) {
        var chunk = state.decoder.end();
        if (chunk && chunk.length) _this.push(chunk);
      }
  
      _this.push(null);
    });
  
    stream.on('data', function (chunk) {
      debug('wrapped data');
      if (state.decoder) chunk = state.decoder.write(chunk);
  
      // don't skip over falsy values in objectMode
      if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
  
      var ret = _this.push(chunk);
      if (!ret) {
        paused = true;
        stream.pause();
      }
    });
  
    // proxy all the other methods.
    // important when wrapping filters and duplexes.
    for (var i in stream) {
      if (this[i] === undefined && typeof stream[i] === 'function') {
        this[i] = function (method) {
          return function () {
            return stream[method].apply(stream, arguments);
          };
        }(i);
      }
    }
  
    // proxy certain important events.
    for (var n = 0; n < kProxyEvents.length; n++) {
      stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
    }
  
    // when we try to consume some more bytes, simply unpause the
    // underlying stream.
    this._read = function (n) {
      debug('wrapped _read', n);
      if (paused) {
        paused = false;
        stream.resume();
      }
    };
  
    return this;
  };
  
  Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._readableState.highWaterMark;
    }
  });
  
  // exposed for testing purposes only.
  Readable._fromList = fromList;
  
  // Pluck off n bytes from an array of buffers.
  // Length is the combined lengths of all the buffers in the list.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function fromList(n, state) {
    // nothing buffered
    if (state.length === 0) return null;
  
    var ret;
    if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
      // read it all, truncate the list
      if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
      state.buffer.clear();
    } else {
      // read part of list
      ret = fromListPartial(n, state.buffer, state.decoder);
    }
  
    return ret;
  }
  
  // Extracts only enough buffered data to satisfy the amount requested.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function fromListPartial(n, list, hasStrings) {
    var ret;
    if (n < list.head.data.length) {
      // slice is the same for buffers and strings
      ret = list.head.data.slice(0, n);
      list.head.data = list.head.data.slice(n);
    } else if (n === list.head.data.length) {
      // first chunk is a perfect match
      ret = list.shift();
    } else {
      // result spans more than one buffer
      ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
    }
    return ret;
  }
  
  // Copies a specified amount of characters from the list of buffered data
  // chunks.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function copyFromBufferString(n, list) {
    var p = list.head;
    var c = 1;
    var ret = p.data;
    n -= ret.length;
    while (p = p.next) {
      var str = p.data;
      var nb = n > str.length ? str.length : n;
      if (nb === str.length) ret += str;else ret += str.slice(0, n);
      n -= nb;
      if (n === 0) {
        if (nb === str.length) {
          ++c;
          if (p.next) list.head = p.next;else list.head = list.tail = null;
        } else {
          list.head = p;
          p.data = str.slice(nb);
        }
        break;
      }
      ++c;
    }
    list.length -= c;
    return ret;
  }
  
  // Copies a specified amount of bytes from the list of buffered data chunks.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function copyFromBuffer(n, list) {
    var ret = Buffer.allocUnsafe(n);
    var p = list.head;
    var c = 1;
    p.data.copy(ret);
    n -= p.data.length;
    while (p = p.next) {
      var buf = p.data;
      var nb = n > buf.length ? buf.length : n;
      buf.copy(ret, ret.length - n, 0, nb);
      n -= nb;
      if (n === 0) {
        if (nb === buf.length) {
          ++c;
          if (p.next) list.head = p.next;else list.head = list.tail = null;
        } else {
          list.head = p;
          p.data = buf.slice(nb);
        }
        break;
      }
      ++c;
    }
    list.length -= c;
    return ret;
  }
  
  function endReadable(stream) {
    var state = stream._readableState;
  
    // If we get here before consuming all the bytes, then that is a
    // bug in node.  Should never happen.
    if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
  
    if (!state.endEmitted) {
      state.ended = true;
      pna.nextTick(endReadableNT, state, stream);
    }
  }
  
  function endReadableNT(state, stream) {
    // Check that we didn't get one last unshift.
    if (!state.endEmitted && state.length === 0) {
      state.endEmitted = true;
      stream.readable = false;
      stream.emit('end');
    }
  }
  
  function indexOf(xs, x) {
    for (var i = 0, l = xs.length; i < l; i++) {
      if (xs[i] === x) return i;
    }
    return -1;
  }
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{"./_stream_duplex":106,"./internal/streams/BufferList":111,"./internal/streams/destroy":112,"./internal/streams/stream":113,"_process":101,"core-util-is":58,"events":93,"inherits":96,"isarray":98,"process-nextick-args":100,"safe-buffer":116,"string_decoder/":114,"util":53}],109:[function(require,module,exports){
  // 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.
  
  // a transform stream is a readable/writable stream where you do
  // something with the data.  Sometimes it's called a "filter",
  // but that's not a great name for it, since that implies a thing where
  // some bits pass through, and others are simply ignored.  (That would
  // be a valid example of a transform, of course.)
  //
  // While the output is causally related to the input, it's not a
  // necessarily symmetric or synchronous transformation.  For example,
  // a zlib stream might take multiple plain-text writes(), and then
  // emit a single compressed chunk some time in the future.
  //
  // Here's how this works:
  //
  // The Transform stream has all the aspects of the readable and writable
  // stream classes.  When you write(chunk), that calls _write(chunk,cb)
  // internally, and returns false if there's a lot of pending writes
  // buffered up.  When you call read(), that calls _read(n) until
  // there's enough pending readable data buffered up.
  //
  // In a transform stream, the written data is placed in a buffer.  When
  // _read(n) is called, it transforms the queued up data, calling the
  // buffered _write cb's as it consumes chunks.  If consuming a single
  // written chunk would result in multiple output chunks, then the first
  // outputted bit calls the readcb, and subsequent chunks just go into
  // the read buffer, and will cause it to emit 'readable' if necessary.
  //
  // This way, back-pressure is actually determined by the reading side,
  // since _read has to be called to start processing a new chunk.  However,
  // a pathological inflate type of transform can cause excessive buffering
  // here.  For example, imagine a stream where every byte of input is
  // interpreted as an integer from 0-255, and then results in that many
  // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
  // 1kb of data being output.  In this case, you could write a very small
  // amount of input, and end up with a very large amount of output.  In
  // such a pathological inflating mechanism, there'd be no way to tell
  // the system to stop doing the transform.  A single 4MB write could
  // cause the system to run out of memory.
  //
  // However, even in such a pathological case, only a single written chunk
  // would be consumed, and then the rest would wait (un-transformed) until
  // the results of the previous transformed chunk were consumed.
  
  'use strict';
  
  module.exports = Transform;
  
  var Duplex = require('./_stream_duplex');
  
  /*<replacement>*/
  var util = require('core-util-is');
  util.inherits = require('inherits');
  /*</replacement>*/
  
  util.inherits(Transform, Duplex);
  
  function afterTransform(er, data) {
    var ts = this._transformState;
    ts.transforming = false;
  
    var cb = ts.writecb;
  
    if (!cb) {
      return this.emit('error', new Error('write callback called multiple times'));
    }
  
    ts.writechunk = null;
    ts.writecb = null;
  
    if (data != null) // single equals check for both `null` and `undefined`
      this.push(data);
  
    cb(er);
  
    var rs = this._readableState;
    rs.reading = false;
    if (rs.needReadable || rs.length < rs.highWaterMark) {
      this._read(rs.highWaterMark);
    }
  }
  
  function Transform(options) {
    if (!(this instanceof Transform)) return new Transform(options);
  
    Duplex.call(this, options);
  
    this._transformState = {
      afterTransform: afterTransform.bind(this),
      needTransform: false,
      transforming: false,
      writecb: null,
      writechunk: null,
      writeencoding: null
    };
  
    // start out asking for a readable event once data is transformed.
    this._readableState.needReadable = true;
  
    // we have implemented the _read method, and done the other things
    // that Readable wants before the first _read call, so unset the
    // sync guard flag.
    this._readableState.sync = false;
  
    if (options) {
      if (typeof options.transform === 'function') this._transform = options.transform;
  
      if (typeof options.flush === 'function') this._flush = options.flush;
    }
  
    // When the writable side finishes, then flush out anything remaining.
    this.on('prefinish', prefinish);
  }
  
  function prefinish() {
    var _this = this;
  
    if (typeof this._flush === 'function') {
      this._flush(function (er, data) {
        done(_this, er, data);
      });
    } else {
      done(this, null, null);
    }
  }
  
  Transform.prototype.push = function (chunk, encoding) {
    this._transformState.needTransform = false;
    return Duplex.prototype.push.call(this, chunk, encoding);
  };
  
  // This is the part where you do stuff!
  // override this function in implementation classes.
  // 'chunk' is an input chunk.
  //
  // Call `push(newChunk)` to pass along transformed output
  // to the readable side.  You may call 'push' zero or more times.
  //
  // Call `cb(err)` when you are done with this chunk.  If you pass
  // an error, then that'll put the hurt on the whole operation.  If you
  // never call cb(), then you'll never get another chunk.
  Transform.prototype._transform = function (chunk, encoding, cb) {
    throw new Error('_transform() is not implemented');
  };
  
  Transform.prototype._write = function (chunk, encoding, cb) {
    var ts = this._transformState;
    ts.writecb = cb;
    ts.writechunk = chunk;
    ts.writeencoding = encoding;
    if (!ts.transforming) {
      var rs = this._readableState;
      if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
    }
  };
  
  // Doesn't matter what the args are here.
  // _transform does all the work.
  // That we got here means that the readable side wants more data.
  Transform.prototype._read = function (n) {
    var ts = this._transformState;
  
    if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
      ts.transforming = true;
      this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
    } else {
      // mark that we need a transform, so that any data that comes in
      // will get processed, now that we've asked for it.
      ts.needTransform = true;
    }
  };
  
  Transform.prototype._destroy = function (err, cb) {
    var _this2 = this;
  
    Duplex.prototype._destroy.call(this, err, function (err2) {
      cb(err2);
      _this2.emit('close');
    });
  };
  
  function done(stream, er, data) {
    if (er) return stream.emit('error', er);
  
    if (data != null) // single equals check for both `null` and `undefined`
      stream.push(data);
  
    // if there's nothing in the write buffer, then that means
    // that nothing more will ever be provided
    if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
  
    if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
  
    return stream.push(null);
  }
  },{"./_stream_duplex":106,"core-util-is":58,"inherits":96}],110:[function(require,module,exports){
  (function (process,global,setImmediate){
  // 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.
  
  // A bit simpler than readable streams.
  // Implement an async ._write(chunk, encoding, cb), and it'll handle all
  // the drain event emission and buffering.
  
  'use strict';
  
  /*<replacement>*/
  
  var pna = require('process-nextick-args');
  /*</replacement>*/
  
  module.exports = Writable;
  
  /* <replacement> */
  function WriteReq(chunk, encoding, cb) {
    this.chunk = chunk;
    this.encoding = encoding;
    this.callback = cb;
    this.next = null;
  }
  
  // It seems a linked list but it is not
  // there will be only 2 of these for each stream
  function CorkedRequest(state) {
    var _this = this;
  
    this.next = null;
    this.entry = null;
    this.finish = function () {
      onCorkedFinish(_this, state);
    };
  }
  /* </replacement> */
  
  /*<replacement>*/
  var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
  /*</replacement>*/
  
  /*<replacement>*/
  var Duplex;
  /*</replacement>*/
  
  Writable.WritableState = WritableState;
  
  /*<replacement>*/
  var util = require('core-util-is');
  util.inherits = require('inherits');
  /*</replacement>*/
  
  /*<replacement>*/
  var internalUtil = {
    deprecate: require('util-deprecate')
  };
  /*</replacement>*/
  
  /*<replacement>*/
  var Stream = require('./internal/streams/stream');
  /*</replacement>*/
  
  /*<replacement>*/
  
  var Buffer = require('safe-buffer').Buffer;
  var OurUint8Array = global.Uint8Array || function () {};
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  
  /*</replacement>*/
  
  var destroyImpl = require('./internal/streams/destroy');
  
  util.inherits(Writable, Stream);
  
  function nop() {}
  
  function WritableState(options, stream) {
    Duplex = Duplex || require('./_stream_duplex');
  
    options = options || {};
  
    // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream.
    // These options can be provided separately as readableXXX and writableXXX.
    var isDuplex = stream instanceof Duplex;
  
    // object stream flag to indicate whether or not this stream
    // contains buffers or objects.
    this.objectMode = !!options.objectMode;
  
    if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
  
    // the point at which write() starts returning false
    // Note: 0 is a valid value, means that we always return false if
    // the entire buffer is not flushed immediately on write()
    var hwm = options.highWaterMark;
    var writableHwm = options.writableHighWaterMark;
    var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
    if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
  
    // cast to ints.
    this.highWaterMark = Math.floor(this.highWaterMark);
  
    // if _final has been called
    this.finalCalled = false;
  
    // drain event flag.
    this.needDrain = false;
    // at the start of calling end()
    this.ending = false;
    // when end() has been called, and returned
    this.ended = false;
    // when 'finish' is emitted
    this.finished = false;
  
    // has it been destroyed
    this.destroyed = false;
  
    // should we decode strings into buffers before passing to _write?
    // this is here so that some node-core streams can optimize string
    // handling at a lower level.
    var noDecode = options.decodeStrings === false;
    this.decodeStrings = !noDecode;
  
    // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
    this.defaultEncoding = options.defaultEncoding || 'utf8';
  
    // not an actual buffer we keep track of, but a measurement
    // of how much we're waiting to get pushed to some underlying
    // socket or file.
    this.length = 0;
  
    // a flag to see when we're in the middle of a write.
    this.writing = false;
  
    // when true all writes will be buffered until .uncork() call
    this.corked = 0;
  
    // a flag to be able to tell if the onwrite cb is called immediately,
    // or on a later tick.  We set this to true at first, because any
    // actions that shouldn't happen until "later" should generally also
    // not happen before the first write call.
    this.sync = true;
  
    // a flag to know if we're processing previously buffered items, which
    // may call the _write() callback in the same tick, so that we don't
    // end up in an overlapped onwrite situation.
    this.bufferProcessing = false;
  
    // the callback that's passed to _write(chunk,cb)
    this.onwrite = function (er) {
      onwrite(stream, er);
    };
  
    // the callback that the user supplies to write(chunk,encoding,cb)
    this.writecb = null;
  
    // the amount that is being written when _write is called.
    this.writelen = 0;
  
    this.bufferedRequest = null;
    this.lastBufferedRequest = null;
  
    // number of pending user-supplied write callbacks
    // this must be 0 before 'finish' can be emitted
    this.pendingcb = 0;
  
    // emit prefinish if the only thing we're waiting for is _write cbs
    // This is relevant for synchronous Transform streams
    this.prefinished = false;
  
    // True if the error was already emitted and should not be thrown again
    this.errorEmitted = false;
  
    // count buffered requests
    this.bufferedRequestCount = 0;
  
    // allocate the first CorkedRequest, there is always
    // one allocated and free to use, and we maintain at most two
    this.corkedRequestsFree = new CorkedRequest(this);
  }
  
  WritableState.prototype.getBuffer = function getBuffer() {
    var current = this.bufferedRequest;
    var out = [];
    while (current) {
      out.push(current);
      current = current.next;
    }
    return out;
  };
  
  (function () {
    try {
      Object.defineProperty(WritableState.prototype, 'buffer', {
        get: internalUtil.deprecate(function () {
          return this.getBuffer();
        }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
      });
    } catch (_) {}
  })();
  
  // Test _writableState for inheritance to account for Duplex streams,
  // whose prototype chain only points to Readable.
  var realHasInstance;
  if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
    realHasInstance = Function.prototype[Symbol.hasInstance];
    Object.defineProperty(Writable, Symbol.hasInstance, {
      value: function (object) {
        if (realHasInstance.call(this, object)) return true;
        if (this !== Writable) return false;
  
        return object && object._writableState instanceof WritableState;
      }
    });
  } else {
    realHasInstance = function (object) {
      return object instanceof this;
    };
  }
  
  function Writable(options) {
    Duplex = Duplex || require('./_stream_duplex');
  
    // Writable ctor is applied to Duplexes, too.
    // `realHasInstance` is necessary because using plain `instanceof`
    // would return false, as no `_writableState` property is attached.
  
    // Trying to use the custom `instanceof` for Writable here will also break the
    // Node.js LazyTransform implementation, which has a non-trivial getter for
    // `_writableState` that would lead to infinite recursion.
    if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
      return new Writable(options);
    }
  
    this._writableState = new WritableState(options, this);
  
    // legacy.
    this.writable = true;
  
    if (options) {
      if (typeof options.write === 'function') this._write = options.write;
  
      if (typeof options.writev === 'function') this._writev = options.writev;
  
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
  
      if (typeof options.final === 'function') this._final = options.final;
    }
  
    Stream.call(this);
  }
  
  // Otherwise people can pipe Writable streams, which is just wrong.
  Writable.prototype.pipe = function () {
    this.emit('error', new Error('Cannot pipe, not readable'));
  };
  
  function writeAfterEnd(stream, cb) {
    var er = new Error('write after end');
    // TODO: defer error events consistently everywhere, not just the cb
    stream.emit('error', er);
    pna.nextTick(cb, er);
  }
  
  // Checks that a user-supplied chunk is valid, especially for the particular
  // mode the stream is in. Currently this means that `null` is never accepted
  // and undefined/non-string values are only allowed in object mode.
  function validChunk(stream, state, chunk, cb) {
    var valid = true;
    var er = false;
  
    if (chunk === null) {
      er = new TypeError('May not write null values to stream');
    } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
      er = new TypeError('Invalid non-string/buffer chunk');
    }
    if (er) {
      stream.emit('error', er);
      pna.nextTick(cb, er);
      valid = false;
    }
    return valid;
  }
  
  Writable.prototype.write = function (chunk, encoding, cb) {
    var state = this._writableState;
    var ret = false;
    var isBuf = !state.objectMode && _isUint8Array(chunk);
  
    if (isBuf && !Buffer.isBuffer(chunk)) {
      chunk = _uint8ArrayToBuffer(chunk);
    }
  
    if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
  
    if (typeof cb !== 'function') cb = nop;
  
    if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
      state.pendingcb++;
      ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
    }
  
    return ret;
  };
  
  Writable.prototype.cork = function () {
    var state = this._writableState;
  
    state.corked++;
  };
  
  Writable.prototype.uncork = function () {
    var state = this._writableState;
  
    if (state.corked) {
      state.corked--;
  
      if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
    }
  };
  
  Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
    // node::ParseEncoding() requires lower case.
    if (typeof encoding === 'string') encoding = encoding.toLowerCase();
    if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
    this._writableState.defaultEncoding = encoding;
    return this;
  };
  
  function decodeChunk(state, chunk, encoding) {
    if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
      chunk = Buffer.from(chunk, encoding);
    }
    return chunk;
  }
  
  Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._writableState.highWaterMark;
    }
  });
  
  // if we're already writing something, then just put this
  // in the queue, and wait our turn.  Otherwise, call _write
  // If we return false, then we need a drain event, so set that flag.
  function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
    if (!isBuf) {
      var newChunk = decodeChunk(state, chunk, encoding);
      if (chunk !== newChunk) {
        isBuf = true;
        encoding = 'buffer';
        chunk = newChunk;
      }
    }
    var len = state.objectMode ? 1 : chunk.length;
  
    state.length += len;
  
    var ret = state.length < state.highWaterMark;
    // we must ensure that previous needDrain will not be reset to false.
    if (!ret) state.needDrain = true;
  
    if (state.writing || state.corked) {
      var last = state.lastBufferedRequest;
      state.lastBufferedRequest = {
        chunk: chunk,
        encoding: encoding,
        isBuf: isBuf,
        callback: cb,
        next: null
      };
      if (last) {
        last.next = state.lastBufferedRequest;
      } else {
        state.bufferedRequest = state.lastBufferedRequest;
      }
      state.bufferedRequestCount += 1;
    } else {
      doWrite(stream, state, false, len, chunk, encoding, cb);
    }
  
    return ret;
  }
  
  function doWrite(stream, state, writev, len, chunk, encoding, cb) {
    state.writelen = len;
    state.writecb = cb;
    state.writing = true;
    state.sync = true;
    if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
    state.sync = false;
  }
  
  function onwriteError(stream, state, sync, er, cb) {
    --state.pendingcb;
  
    if (sync) {
      // defer the callback if we are being called synchronously
      // to avoid piling up things on the stack
      pna.nextTick(cb, er);
      // this can emit finish, and it will always happen
      // after error
      pna.nextTick(finishMaybe, stream, state);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er);
    } else {
      // the caller expect this to happen before if
      // it is async
      cb(er);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er);
      // this can emit finish, but finish must
      // always follow error
      finishMaybe(stream, state);
    }
  }
  
  function onwriteStateUpdate(state) {
    state.writing = false;
    state.writecb = null;
    state.length -= state.writelen;
    state.writelen = 0;
  }
  
  function onwrite(stream, er) {
    var state = stream._writableState;
    var sync = state.sync;
    var cb = state.writecb;
  
    onwriteStateUpdate(state);
  
    if (er) onwriteError(stream, state, sync, er, cb);else {
      // Check if we're actually ready to finish, but don't emit yet
      var finished = needFinish(state);
  
      if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
        clearBuffer(stream, state);
      }
  
      if (sync) {
        /*<replacement>*/
        asyncWrite(afterWrite, stream, state, finished, cb);
        /*</replacement>*/
      } else {
        afterWrite(stream, state, finished, cb);
      }
    }
  }
  
  function afterWrite(stream, state, finished, cb) {
    if (!finished) onwriteDrain(stream, state);
    state.pendingcb--;
    cb();
    finishMaybe(stream, state);
  }
  
  // Must force callback to be called on nextTick, so that we don't
  // emit 'drain' before the write() consumer gets the 'false' return
  // value, and has a chance to attach a 'drain' listener.
  function onwriteDrain(stream, state) {
    if (state.length === 0 && state.needDrain) {
      state.needDrain = false;
      stream.emit('drain');
    }
  }
  
  // if there's something in the buffer waiting, then process it
  function clearBuffer(stream, state) {
    state.bufferProcessing = true;
    var entry = state.bufferedRequest;
  
    if (stream._writev && entry && entry.next) {
      // Fast case, write everything using _writev()
      var l = state.bufferedRequestCount;
      var buffer = new Array(l);
      var holder = state.corkedRequestsFree;
      holder.entry = entry;
  
      var count = 0;
      var allBuffers = true;
      while (entry) {
        buffer[count] = entry;
        if (!entry.isBuf) allBuffers = false;
        entry = entry.next;
        count += 1;
      }
      buffer.allBuffers = allBuffers;
  
      doWrite(stream, state, true, state.length, buffer, '', holder.finish);
  
      // doWrite is almost always async, defer these to save a bit of time
      // as the hot path ends with doWrite
      state.pendingcb++;
      state.lastBufferedRequest = null;
      if (holder.next) {
        state.corkedRequestsFree = holder.next;
        holder.next = null;
      } else {
        state.corkedRequestsFree = new CorkedRequest(state);
      }
      state.bufferedRequestCount = 0;
    } else {
      // Slow case, write chunks one-by-one
      while (entry) {
        var chunk = entry.chunk;
        var encoding = entry.encoding;
        var cb = entry.callback;
        var len = state.objectMode ? 1 : chunk.length;
  
        doWrite(stream, state, false, len, chunk, encoding, cb);
        entry = entry.next;
        state.bufferedRequestCount--;
        // if we didn't call the onwrite immediately, then
        // it means that we need to wait until it does.
        // also, that means that the chunk and cb are currently
        // being processed, so move the buffer counter past them.
        if (state.writing) {
          break;
        }
      }
  
      if (entry === null) state.lastBufferedRequest = null;
    }
  
    state.bufferedRequest = entry;
    state.bufferProcessing = false;
  }
  
  Writable.prototype._write = function (chunk, encoding, cb) {
    cb(new Error('_write() is not implemented'));
  };
  
  Writable.prototype._writev = null;
  
  Writable.prototype.end = function (chunk, encoding, cb) {
    var state = this._writableState;
  
    if (typeof chunk === 'function') {
      cb = chunk;
      chunk = null;
      encoding = null;
    } else if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
  
    // .end() fully uncorks
    if (state.corked) {
      state.corked = 1;
      this.uncork();
    }
  
    // ignore unnecessary end() calls.
    if (!state.ending && !state.finished) endWritable(this, state, cb);
  };
  
  function needFinish(state) {
    return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
  }
  function callFinal(stream, state) {
    stream._final(function (err) {
      state.pendingcb--;
      if (err) {
        stream.emit('error', err);
      }
      state.prefinished = true;
      stream.emit('prefinish');
      finishMaybe(stream, state);
    });
  }
  function prefinish(stream, state) {
    if (!state.prefinished && !state.finalCalled) {
      if (typeof stream._final === 'function') {
        state.pendingcb++;
        state.finalCalled = true;
        pna.nextTick(callFinal, stream, state);
      } else {
        state.prefinished = true;
        stream.emit('prefinish');
      }
    }
  }
  
  function finishMaybe(stream, state) {
    var need = needFinish(state);
    if (need) {
      prefinish(stream, state);
      if (state.pendingcb === 0) {
        state.finished = true;
        stream.emit('finish');
      }
    }
    return need;
  }
  
  function endWritable(stream, state, cb) {
    state.ending = true;
    finishMaybe(stream, state);
    if (cb) {
      if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
    }
    state.ended = true;
    stream.writable = false;
  }
  
  function onCorkedFinish(corkReq, state, err) {
    var entry = corkReq.entry;
    corkReq.entry = null;
    while (entry) {
      var cb = entry.callback;
      state.pendingcb--;
      cb(err);
      entry = entry.next;
    }
    if (state.corkedRequestsFree) {
      state.corkedRequestsFree.next = corkReq;
    } else {
      state.corkedRequestsFree = corkReq;
    }
  }
  
  Object.defineProperty(Writable.prototype, 'destroyed', {
    get: function () {
      if (this._writableState === undefined) {
        return false;
      }
      return this._writableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._writableState) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._writableState.destroyed = value;
    }
  });
  
  Writable.prototype.destroy = destroyImpl.destroy;
  Writable.prototype._undestroy = destroyImpl.undestroy;
  Writable.prototype._destroy = function (err, cb) {
    this.end();
    cb(err);
  };
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
  
  },{"./_stream_duplex":106,"./internal/streams/destroy":112,"./internal/streams/stream":113,"_process":101,"core-util-is":58,"inherits":96,"process-nextick-args":100,"safe-buffer":116,"timers":121,"util-deprecate":126}],111:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var Buffer = require('safe-buffer').Buffer;
  var util = require('util');
  
  function copyBuffer(src, target, offset) {
    src.copy(target, offset);
  }
  
  module.exports = function () {
    function BufferList() {
      _classCallCheck(this, BufferList);
  
      this.head = null;
      this.tail = null;
      this.length = 0;
    }
  
    BufferList.prototype.push = function push(v) {
      var entry = { data: v, next: null };
      if (this.length > 0) this.tail.next = entry;else this.head = entry;
      this.tail = entry;
      ++this.length;
    };
  
    BufferList.prototype.unshift = function unshift(v) {
      var entry = { data: v, next: this.head };
      if (this.length === 0) this.tail = entry;
      this.head = entry;
      ++this.length;
    };
  
    BufferList.prototype.shift = function shift() {
      if (this.length === 0) return;
      var ret = this.head.data;
      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
      --this.length;
      return ret;
    };
  
    BufferList.prototype.clear = function clear() {
      this.head = this.tail = null;
      this.length = 0;
    };
  
    BufferList.prototype.join = function join(s) {
      if (this.length === 0) return '';
      var p = this.head;
      var ret = '' + p.data;
      while (p = p.next) {
        ret += s + p.data;
      }return ret;
    };
  
    BufferList.prototype.concat = function concat(n) {
      if (this.length === 0) return Buffer.alloc(0);
      if (this.length === 1) return this.head.data;
      var ret = Buffer.allocUnsafe(n >>> 0);
      var p = this.head;
      var i = 0;
      while (p) {
        copyBuffer(p.data, ret, i);
        i += p.data.length;
        p = p.next;
      }
      return ret;
    };
  
    return BufferList;
  }();
  
  if (util && util.inspect && util.inspect.custom) {
    module.exports.prototype[util.inspect.custom] = function () {
      var obj = util.inspect({ length: this.length });
      return this.constructor.name + ' ' + obj;
    };
  }
  },{"safe-buffer":116,"util":53}],112:[function(require,module,exports){
  'use strict';
  
  /*<replacement>*/
  
  var pna = require('process-nextick-args');
  /*</replacement>*/
  
  // undocumented cb() API, needed for core, not for public API
  function destroy(err, cb) {
    var _this = this;
  
    var readableDestroyed = this._readableState && this._readableState.destroyed;
    var writableDestroyed = this._writableState && this._writableState.destroyed;
  
    if (readableDestroyed || writableDestroyed) {
      if (cb) {
        cb(err);
      } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
        pna.nextTick(emitErrorNT, this, err);
      }
      return this;
    }
  
    // we set destroyed to true before firing error callbacks in order
    // to make it re-entrance safe in case destroy() is called within callbacks
  
    if (this._readableState) {
      this._readableState.destroyed = true;
    }
  
    // if this is a duplex stream mark the writable part as destroyed as well
    if (this._writableState) {
      this._writableState.destroyed = true;
    }
  
    this._destroy(err || null, function (err) {
      if (!cb && err) {
        pna.nextTick(emitErrorNT, _this, err);
        if (_this._writableState) {
          _this._writableState.errorEmitted = true;
        }
      } else if (cb) {
        cb(err);
      }
    });
  
    return this;
  }
  
  function undestroy() {
    if (this._readableState) {
      this._readableState.destroyed = false;
      this._readableState.reading = false;
      this._readableState.ended = false;
      this._readableState.endEmitted = false;
    }
  
    if (this._writableState) {
      this._writableState.destroyed = false;
      this._writableState.ended = false;
      this._writableState.ending = false;
      this._writableState.finished = false;
      this._writableState.errorEmitted = false;
    }
  }
  
  function emitErrorNT(self, err) {
    self.emit('error', err);
  }
  
  module.exports = {
    destroy: destroy,
    undestroy: undestroy
  };
  },{"process-nextick-args":100}],113:[function(require,module,exports){
  module.exports = require('events').EventEmitter;
  
  },{"events":93}],114:[function(require,module,exports){
  // 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.
  
  'use strict';
  
  /*<replacement>*/
  
  var Buffer = require('safe-buffer').Buffer;
  /*</replacement>*/
  
  var isEncoding = Buffer.isEncoding || function (encoding) {
    encoding = '' + encoding;
    switch (encoding && encoding.toLowerCase()) {
      case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
        return true;
      default:
        return false;
    }
  };
  
  function _normalizeEncoding(enc) {
    if (!enc) return 'utf8';
    var retried;
    while (true) {
      switch (enc) {
        case 'utf8':
        case 'utf-8':
          return 'utf8';
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return 'utf16le';
        case 'latin1':
        case 'binary':
          return 'latin1';
        case 'base64':
        case 'ascii':
        case 'hex':
          return enc;
        default:
          if (retried) return; // undefined
          enc = ('' + enc).toLowerCase();
          retried = true;
      }
    }
  };
  
  // Do not cache `Buffer.isEncoding` when checking encoding names as some
  // modules monkey-patch it to support additional encodings
  function normalizeEncoding(enc) {
    var nenc = _normalizeEncoding(enc);
    if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
    return nenc || enc;
  }
  
  // StringDecoder provides an interface for efficiently splitting a series of
  // buffers into a series of JS strings without breaking apart multi-byte
  // characters.
  exports.StringDecoder = StringDecoder;
  function StringDecoder(encoding) {
    this.encoding = normalizeEncoding(encoding);
    var nb;
    switch (this.encoding) {
      case 'utf16le':
        this.text = utf16Text;
        this.end = utf16End;
        nb = 4;
        break;
      case 'utf8':
        this.fillLast = utf8FillLast;
        nb = 4;
        break;
      case 'base64':
        this.text = base64Text;
        this.end = base64End;
        nb = 3;
        break;
      default:
        this.write = simpleWrite;
        this.end = simpleEnd;
        return;
    }
    this.lastNeed = 0;
    this.lastTotal = 0;
    this.lastChar = Buffer.allocUnsafe(nb);
  }
  
  StringDecoder.prototype.write = function (buf) {
    if (buf.length === 0) return '';
    var r;
    var i;
    if (this.lastNeed) {
      r = this.fillLast(buf);
      if (r === undefined) return '';
      i = this.lastNeed;
      this.lastNeed = 0;
    } else {
      i = 0;
    }
    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
    return r || '';
  };
  
  StringDecoder.prototype.end = utf8End;
  
  // Returns only complete characters in a Buffer
  StringDecoder.prototype.text = utf8Text;
  
  // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
  StringDecoder.prototype.fillLast = function (buf) {
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
    this.lastNeed -= buf.length;
  };
  
  // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
  // continuation byte. If an invalid byte is detected, -2 is returned.
  function utf8CheckByte(byte) {
    if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
    return byte >> 6 === 0x02 ? -1 : -2;
  }
  
  // Checks at most 3 bytes at the end of a Buffer in order to detect an
  // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
  // needed to complete the UTF-8 character (if applicable) are returned.
  function utf8CheckIncomplete(self, buf, i) {
    var j = buf.length - 1;
    if (j < i) return 0;
    var nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 1;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 2;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) {
        if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
      }
      return nb;
    }
    return 0;
  }
  
  // Validates as many continuation bytes for a multi-byte UTF-8 character as
  // needed or are available. If we see a non-continuation byte where we expect
  // one, we "replace" the validated continuation bytes we've seen so far with
  // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
  // behavior. The continuation byte check is included three times in the case
  // where all of the continuation bytes for a character exist in the same buffer.
  // It is also done this way as a slight performance increase instead of using a
  // loop.
  function utf8CheckExtraBytes(self, buf, p) {
    if ((buf[0] & 0xC0) !== 0x80) {
      self.lastNeed = 0;
      return '\ufffd';
    }
    if (self.lastNeed > 1 && buf.length > 1) {
      if ((buf[1] & 0xC0) !== 0x80) {
        self.lastNeed = 1;
        return '\ufffd';
      }
      if (self.lastNeed > 2 && buf.length > 2) {
        if ((buf[2] & 0xC0) !== 0x80) {
          self.lastNeed = 2;
          return '\ufffd';
        }
      }
    }
  }
  
  // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
  function utf8FillLast(buf) {
    var p = this.lastTotal - this.lastNeed;
    var r = utf8CheckExtraBytes(this, buf, p);
    if (r !== undefined) return r;
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, p, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, p, 0, buf.length);
    this.lastNeed -= buf.length;
  }
  
  // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
  // partial character, the character's bytes are buffered until the required
  // number of bytes are available.
  function utf8Text(buf, i) {
    var total = utf8CheckIncomplete(this, buf, i);
    if (!this.lastNeed) return buf.toString('utf8', i);
    this.lastTotal = total;
    var end = buf.length - (total - this.lastNeed);
    buf.copy(this.lastChar, 0, end);
    return buf.toString('utf8', i, end);
  }
  
  // For UTF-8, a replacement character is added when ending on a partial
  // character.
  function utf8End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + '\ufffd';
    return r;
  }
  
  // UTF-16LE typically needs two bytes per character, but even if we have an even
  // number of bytes available, we need to check if we end on a leading/high
  // surrogate. In that case, we need to wait for the next two bytes in order to
  // decode the last character properly.
  function utf16Text(buf, i) {
    if ((buf.length - i) % 2 === 0) {
      var r = buf.toString('utf16le', i);
      if (r) {
        var c = r.charCodeAt(r.length - 1);
        if (c >= 0xD800 && c <= 0xDBFF) {
          this.lastNeed = 2;
          this.lastTotal = 4;
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
          return r.slice(0, -1);
        }
      }
      return r;
    }
    this.lastNeed = 1;
    this.lastTotal = 2;
    this.lastChar[0] = buf[buf.length - 1];
    return buf.toString('utf16le', i, buf.length - 1);
  }
  
  // For UTF-16LE we do not explicitly append special replacement characters if we
  // end on a partial character, we simply let v8 handle that.
  function utf16End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) {
      var end = this.lastTotal - this.lastNeed;
      return r + this.lastChar.toString('utf16le', 0, end);
    }
    return r;
  }
  
  function base64Text(buf, i) {
    var n = (buf.length - i) % 3;
    if (n === 0) return buf.toString('base64', i);
    this.lastNeed = 3 - n;
    this.lastTotal = 3;
    if (n === 1) {
      this.lastChar[0] = buf[buf.length - 1];
    } else {
      this.lastChar[0] = buf[buf.length - 2];
      this.lastChar[1] = buf[buf.length - 1];
    }
    return buf.toString('base64', i, buf.length - n);
  }
  
  function base64End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
    return r;
  }
  
  // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
  function simpleWrite(buf) {
    return buf.toString(this.encoding);
  }
  
  function simpleEnd(buf) {
    return buf && buf.length ? this.write(buf) : '';
  }
  },{"safe-buffer":116}],115:[function(require,module,exports){
  exports = module.exports = require('./lib/_stream_readable.js');
  exports.Stream = exports;
  exports.Readable = exports;
  exports.Writable = require('./lib/_stream_writable.js');
  exports.Duplex = require('./lib/_stream_duplex.js');
  exports.Transform = require('./lib/_stream_transform.js');
  exports.PassThrough = require('./lib/_stream_passthrough.js');
  
  },{"./lib/_stream_duplex.js":106,"./lib/_stream_passthrough.js":107,"./lib/_stream_readable.js":108,"./lib/_stream_transform.js":109,"./lib/_stream_writable.js":110}],116:[function(require,module,exports){
  /* eslint-disable node/no-deprecated-api */
  var buffer = require('buffer')
  var Buffer = buffer.Buffer
  
  // alternative to using Object.keys for old browsers
  function copyProps (src, dst) {
    for (var key in src) {
      dst[key] = src[key]
    }
  }
  if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
    module.exports = buffer
  } else {
    // Copy properties from require('buffer')
    copyProps(buffer, exports)
    exports.Buffer = SafeBuffer
  }
  
  function SafeBuffer (arg, encodingOrOffset, length) {
    return Buffer(arg, encodingOrOffset, length)
  }
  
  // Copy static methods from Buffer
  copyProps(Buffer, SafeBuffer)
  
  SafeBuffer.from = function (arg, encodingOrOffset, length) {
    if (typeof arg === 'number') {
      throw new TypeError('Argument must not be a number')
    }
    return Buffer(arg, encodingOrOffset, length)
  }
  
  SafeBuffer.alloc = function (size, fill, encoding) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    var buf = Buffer(size)
    if (fill !== undefined) {
      if (typeof encoding === 'string') {
        buf.fill(fill, encoding)
      } else {
        buf.fill(fill)
      }
    } else {
      buf.fill(0)
    }
    return buf
  }
  
  SafeBuffer.allocUnsafe = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return Buffer(size)
  }
  
  SafeBuffer.allocUnsafeSlow = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return buffer.SlowBuffer(size)
  }
  
  },{"buffer":55}],117:[function(require,module,exports){
  (function (global){
  var ClientRequest = require('./lib/request')
  var response = require('./lib/response')
  var extend = require('xtend')
  var statusCodes = require('builtin-status-codes')
  var url = require('url')
  
  var http = exports
  
  http.request = function (opts, cb) {
  	if (typeof opts === 'string')
  		opts = url.parse(opts)
  	else
  		opts = extend(opts)
  
  	// Normally, the page is loaded from http or https, so not specifying a protocol
  	// will result in a (valid) protocol-relative url. However, this won't work if
  	// the protocol is something else, like 'file:'
  	var defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''
  
  	var protocol = opts.protocol || defaultProtocol
  	var host = opts.hostname || opts.host
  	var port = opts.port
  	var path = opts.path || '/'
  
  	// Necessary for IPv6 addresses
  	if (host && host.indexOf(':') !== -1)
  		host = '[' + host + ']'
  
  	// This may be a relative url. The browser should always be able to interpret it correctly.
  	opts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path
  	opts.method = (opts.method || 'GET').toUpperCase()
  	opts.headers = opts.headers || {}
  
  	// Also valid opts.auth, opts.mode
  
  	var req = new ClientRequest(opts)
  	if (cb)
  		req.on('response', cb)
  	return req
  }
  
  http.get = function get (opts, cb) {
  	var req = http.request(opts, cb)
  	req.end()
  	return req
  }
  
  http.ClientRequest = ClientRequest
  http.IncomingMessage = response.IncomingMessage
  
  http.Agent = function () {}
  http.Agent.defaultMaxSockets = 4
  
  http.globalAgent = new http.Agent()
  
  http.STATUS_CODES = statusCodes
  
  http.METHODS = [
  	'CHECKOUT',
  	'CONNECT',
  	'COPY',
  	'DELETE',
  	'GET',
  	'HEAD',
  	'LOCK',
  	'M-SEARCH',
  	'MERGE',
  	'MKACTIVITY',
  	'MKCOL',
  	'MOVE',
  	'NOTIFY',
  	'OPTIONS',
  	'PATCH',
  	'POST',
  	'PROPFIND',
  	'PROPPATCH',
  	'PURGE',
  	'PUT',
  	'REPORT',
  	'SEARCH',
  	'SUBSCRIBE',
  	'TRACE',
  	'UNLOCK',
  	'UNSUBSCRIBE'
  ]
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{"./lib/request":119,"./lib/response":120,"builtin-status-codes":56,"url":123,"xtend":133}],118:[function(require,module,exports){
  (function (global){
  exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)
  
  exports.writableStream = isFunction(global.WritableStream)
  
  exports.abortController = isFunction(global.AbortController)
  
  exports.blobConstructor = false
  try {
  	new Blob([new ArrayBuffer(1)])
  	exports.blobConstructor = true
  } catch (e) {}
  
  // The xhr request to example.com may violate some restrictive CSP configurations,
  // so if we're running in a browser that supports `fetch`, avoid calling getXHR()
  // and assume support for certain features below.
  var xhr
  function getXHR () {
  	// Cache the xhr value
  	if (xhr !== undefined) return xhr
  
  	if (global.XMLHttpRequest) {
  		xhr = new global.XMLHttpRequest()
  		// If XDomainRequest is available (ie only, where xhr might not work
  		// cross domain), use the page location. Otherwise use example.com
  		// Note: this doesn't actually make an http request.
  		try {
  			xhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')
  		} catch(e) {
  			xhr = null
  		}
  	} else {
  		// Service workers don't have XHR
  		xhr = null
  	}
  	return xhr
  }
  
  function checkTypeSupport (type) {
  	var xhr = getXHR()
  	if (!xhr) return false
  	try {
  		xhr.responseType = type
  		return xhr.responseType === type
  	} catch (e) {}
  	return false
  }
  
  // For some strange reason, Safari 7.0 reports typeof global.ArrayBuffer === 'object'.
  // Safari 7.1 appears to have fixed this bug.
  var haveArrayBuffer = typeof global.ArrayBuffer !== 'undefined'
  var haveSlice = haveArrayBuffer && isFunction(global.ArrayBuffer.prototype.slice)
  
  // If fetch is supported, then arraybuffer will be supported too. Skip calling
  // checkTypeSupport(), since that calls getXHR().
  exports.arraybuffer = exports.fetch || (haveArrayBuffer && checkTypeSupport('arraybuffer'))
  
  // These next two tests unavoidably show warnings in Chrome. Since fetch will always
  // be used if it's available, just return false for these to avoid the warnings.
  exports.msstream = !exports.fetch && haveSlice && checkTypeSupport('ms-stream')
  exports.mozchunkedarraybuffer = !exports.fetch && haveArrayBuffer &&
  	checkTypeSupport('moz-chunked-arraybuffer')
  
  // If fetch is supported, then overrideMimeType will be supported too. Skip calling
  // getXHR().
  exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)
  
  exports.vbArray = isFunction(global.VBArray)
  
  function isFunction (value) {
  	return typeof value === 'function'
  }
  
  xhr = null // Help gc
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{}],119:[function(require,module,exports){
  (function (process,global,Buffer){
  var capability = require('./capability')
  var inherits = require('inherits')
  var response = require('./response')
  var stream = require('readable-stream')
  var toArrayBuffer = require('to-arraybuffer')
  
  var IncomingMessage = response.IncomingMessage
  var rStates = response.readyStates
  
  function decideMode (preferBinary, useFetch) {
  	if (capability.fetch && useFetch) {
  		return 'fetch'
  	} else if (capability.mozchunkedarraybuffer) {
  		return 'moz-chunked-arraybuffer'
  	} else if (capability.msstream) {
  		return 'ms-stream'
  	} else if (capability.arraybuffer && preferBinary) {
  		return 'arraybuffer'
  	} else if (capability.vbArray && preferBinary) {
  		return 'text:vbarray'
  	} else {
  		return 'text'
  	}
  }
  
  var ClientRequest = module.exports = function (opts) {
  	var self = this
  	stream.Writable.call(self)
  
  	self._opts = opts
  	self._body = []
  	self._headers = {}
  	if (opts.auth)
  		self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))
  	Object.keys(opts.headers).forEach(function (name) {
  		self.setHeader(name, opts.headers[name])
  	})
  
  	var preferBinary
  	var useFetch = true
  	if (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {
  		// If the use of XHR should be preferred. Not typically needed.
  		useFetch = false
  		preferBinary = true
  	} else if (opts.mode === 'prefer-streaming') {
  		// If streaming is a high priority but binary compatibility and
  		// the accuracy of the 'content-type' header aren't
  		preferBinary = false
  	} else if (opts.mode === 'allow-wrong-content-type') {
  		// If streaming is more important than preserving the 'content-type' header
  		preferBinary = !capability.overrideMimeType
  	} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
  		// Use binary if text streaming may corrupt data or the content-type header, or for speed
  		preferBinary = true
  	} else {
  		throw new Error('Invalid value for opts.mode')
  	}
  	self._mode = decideMode(preferBinary, useFetch)
  	self._fetchTimer = null
  
  	self.on('finish', function () {
  		self._onFinish()
  	})
  }
  
  inherits(ClientRequest, stream.Writable)
  
  ClientRequest.prototype.setHeader = function (name, value) {
  	var self = this
  	var lowerName = name.toLowerCase()
  	// This check is not necessary, but it prevents warnings from browsers about setting unsafe
  	// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
  	// http-browserify did it, so I will too.
  	if (unsafeHeaders.indexOf(lowerName) !== -1)
  		return
  
  	self._headers[lowerName] = {
  		name: name,
  		value: value
  	}
  }
  
  ClientRequest.prototype.getHeader = function (name) {
  	var header = this._headers[name.toLowerCase()]
  	if (header)
  		return header.value
  	return null
  }
  
  ClientRequest.prototype.removeHeader = function (name) {
  	var self = this
  	delete self._headers[name.toLowerCase()]
  }
  
  ClientRequest.prototype._onFinish = function () {
  	var self = this
  
  	if (self._destroyed)
  		return
  	var opts = self._opts
  
  	var headersObj = self._headers
  	var body = null
  	if (opts.method !== 'GET' && opts.method !== 'HEAD') {
  		if (capability.arraybuffer) {
  			body = toArrayBuffer(Buffer.concat(self._body))
  		} else if (capability.blobConstructor) {
  			body = new global.Blob(self._body.map(function (buffer) {
  				return toArrayBuffer(buffer)
  			}), {
  				type: (headersObj['content-type'] || {}).value || ''
  			})
  		} else {
  			// get utf8 string
  			body = Buffer.concat(self._body).toString()
  		}
  	}
  
  	// create flattened list of headers
  	var headersList = []
  	Object.keys(headersObj).forEach(function (keyName) {
  		var name = headersObj[keyName].name
  		var value = headersObj[keyName].value
  		if (Array.isArray(value)) {
  			value.forEach(function (v) {
  				headersList.push([name, v])
  			})
  		} else {
  			headersList.push([name, value])
  		}
  	})
  
  	if (self._mode === 'fetch') {
  		var signal = null
  		var fetchTimer = null
  		if (capability.abortController) {
  			var controller = new AbortController()
  			signal = controller.signal
  			self._fetchAbortController = controller
  
  			if ('requestTimeout' in opts && opts.requestTimeout !== 0) {
  				self._fetchTimer = global.setTimeout(function () {
  					self.emit('requestTimeout')
  					if (self._fetchAbortController)
  						self._fetchAbortController.abort()
  				}, opts.requestTimeout)
  			}
  		}
  
  		global.fetch(self._opts.url, {
  			method: self._opts.method,
  			headers: headersList,
  			body: body || undefined,
  			mode: 'cors',
  			credentials: opts.withCredentials ? 'include' : 'same-origin',
  			signal: signal
  		}).then(function (response) {
  			self._fetchResponse = response
  			self._connect()
  		}, function (reason) {
  			global.clearTimeout(self._fetchTimer)
  			if (!self._destroyed)
  				self.emit('error', reason)
  		})
  	} else {
  		var xhr = self._xhr = new global.XMLHttpRequest()
  		try {
  			xhr.open(self._opts.method, self._opts.url, true)
  		} catch (err) {
  			process.nextTick(function () {
  				self.emit('error', err)
  			})
  			return
  		}
  
  		// Can't set responseType on really old browsers
  		if ('responseType' in xhr)
  			xhr.responseType = self._mode.split(':')[0]
  
  		if ('withCredentials' in xhr)
  			xhr.withCredentials = !!opts.withCredentials
  
  		if (self._mode === 'text' && 'overrideMimeType' in xhr)
  			xhr.overrideMimeType('text/plain; charset=x-user-defined')
  
  		if ('requestTimeout' in opts) {
  			xhr.timeout = opts.requestTimeout
  			xhr.ontimeout = function () {
  				self.emit('requestTimeout')
  			}
  		}
  
  		headersList.forEach(function (header) {
  			xhr.setRequestHeader(header[0], header[1])
  		})
  
  		self._response = null
  		xhr.onreadystatechange = function () {
  			switch (xhr.readyState) {
  				case rStates.LOADING:
  				case rStates.DONE:
  					self._onXHRProgress()
  					break
  			}
  		}
  		// Necessary for streaming in Firefox, since xhr.response is ONLY defined
  		// in onprogress, not in onreadystatechange with xhr.readyState = 3
  		if (self._mode === 'moz-chunked-arraybuffer') {
  			xhr.onprogress = function () {
  				self._onXHRProgress()
  			}
  		}
  
  		xhr.onerror = function () {
  			if (self._destroyed)
  				return
  			self.emit('error', new Error('XHR error'))
  		}
  
  		try {
  			xhr.send(body)
  		} catch (err) {
  			process.nextTick(function () {
  				self.emit('error', err)
  			})
  			return
  		}
  	}
  }
  
  /**
   * Checks if xhr.status is readable and non-zero, indicating no error.
   * Even though the spec says it should be available in readyState 3,
   * accessing it throws an exception in IE8
   */
  function statusValid (xhr) {
  	try {
  		var status = xhr.status
  		return (status !== null && status !== 0)
  	} catch (e) {
  		return false
  	}
  }
  
  ClientRequest.prototype._onXHRProgress = function () {
  	var self = this
  
  	if (!statusValid(self._xhr) || self._destroyed)
  		return
  
  	if (!self._response)
  		self._connect()
  
  	self._response._onXHRProgress()
  }
  
  ClientRequest.prototype._connect = function () {
  	var self = this
  
  	if (self._destroyed)
  		return
  
  	self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._fetchTimer)
  	self._response.on('error', function(err) {
  		self.emit('error', err)
  	})
  
  	self.emit('response', self._response)
  }
  
  ClientRequest.prototype._write = function (chunk, encoding, cb) {
  	var self = this
  
  	self._body.push(chunk)
  	cb()
  }
  
  ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
  	var self = this
  	self._destroyed = true
  	global.clearTimeout(self._fetchTimer)
  	if (self._response)
  		self._response._destroyed = true
  	if (self._xhr)
  		self._xhr.abort()
  	else if (self._fetchAbortController)
  		self._fetchAbortController.abort()
  }
  
  ClientRequest.prototype.end = function (data, encoding, cb) {
  	var self = this
  	if (typeof data === 'function') {
  		cb = data
  		data = undefined
  	}
  
  	stream.Writable.prototype.end.call(self, data, encoding, cb)
  }
  
  ClientRequest.prototype.flushHeaders = function () {}
  ClientRequest.prototype.setTimeout = function () {}
  ClientRequest.prototype.setNoDelay = function () {}
  ClientRequest.prototype.setSocketKeepAlive = function () {}
  
  // Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
  var unsafeHeaders = [
  	'accept-charset',
  	'accept-encoding',
  	'access-control-request-headers',
  	'access-control-request-method',
  	'connection',
  	'content-length',
  	'cookie',
  	'cookie2',
  	'date',
  	'dnt',
  	'expect',
  	'host',
  	'keep-alive',
  	'origin',
  	'referer',
  	'te',
  	'trailer',
  	'transfer-encoding',
  	'upgrade',
  	'via'
  ]
  
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
  
  },{"./capability":118,"./response":120,"_process":101,"buffer":55,"inherits":96,"readable-stream":115,"to-arraybuffer":122}],120:[function(require,module,exports){
  (function (process,global,Buffer){
  var capability = require('./capability')
  var inherits = require('inherits')
  var stream = require('readable-stream')
  
  var rStates = exports.readyStates = {
  	UNSENT: 0,
  	OPENED: 1,
  	HEADERS_RECEIVED: 2,
  	LOADING: 3,
  	DONE: 4
  }
  
  var IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, fetchTimer) {
  	var self = this
  	stream.Readable.call(self)
  
  	self._mode = mode
  	self.headers = {}
  	self.rawHeaders = []
  	self.trailers = {}
  	self.rawTrailers = []
  
  	// Fake the 'close' event, but only once 'end' fires
  	self.on('end', function () {
  		// The nextTick is necessary to prevent the 'request' module from causing an infinite loop
  		process.nextTick(function () {
  			self.emit('close')
  		})
  	})
  
  	if (mode === 'fetch') {
  		self._fetchResponse = response
  
  		self.url = response.url
  		self.statusCode = response.status
  		self.statusMessage = response.statusText
  		
  		response.headers.forEach(function (header, key){
  			self.headers[key.toLowerCase()] = header
  			self.rawHeaders.push(key, header)
  		})
  
  		if (capability.writableStream) {
  			var writable = new WritableStream({
  				write: function (chunk) {
  					return new Promise(function (resolve, reject) {
  						if (self._destroyed) {
  							reject()
  						} else if(self.push(new Buffer(chunk))) {
  							resolve()
  						} else {
  							self._resumeFetch = resolve
  						}
  					})
  				},
  				close: function () {
  					global.clearTimeout(fetchTimer)
  					if (!self._destroyed)
  						self.push(null)
  				},
  				abort: function (err) {
  					if (!self._destroyed)
  						self.emit('error', err)
  				}
  			})
  
  			try {
  				response.body.pipeTo(writable).catch(function (err) {
  					global.clearTimeout(fetchTimer)
  					if (!self._destroyed)
  						self.emit('error', err)
  				})
  				return
  			} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this
  		}
  		// fallback for when writableStream or pipeTo aren't available
  		var reader = response.body.getReader()
  		function read () {
  			reader.read().then(function (result) {
  				if (self._destroyed)
  					return
  				if (result.done) {
  					global.clearTimeout(fetchTimer)
  					self.push(null)
  					return
  				}
  				self.push(new Buffer(result.value))
  				read()
  			}).catch(function (err) {
  				global.clearTimeout(fetchTimer)
  				if (!self._destroyed)
  					self.emit('error', err)
  			})
  		}
  		read()
  	} else {
  		self._xhr = xhr
  		self._pos = 0
  
  		self.url = xhr.responseURL
  		self.statusCode = xhr.status
  		self.statusMessage = xhr.statusText
  		var headers = xhr.getAllResponseHeaders().split(/\r?\n/)
  		headers.forEach(function (header) {
  			var matches = header.match(/^([^:]+):\s*(.*)/)
  			if (matches) {
  				var key = matches[1].toLowerCase()
  				if (key === 'set-cookie') {
  					if (self.headers[key] === undefined) {
  						self.headers[key] = []
  					}
  					self.headers[key].push(matches[2])
  				} else if (self.headers[key] !== undefined) {
  					self.headers[key] += ', ' + matches[2]
  				} else {
  					self.headers[key] = matches[2]
  				}
  				self.rawHeaders.push(matches[1], matches[2])
  			}
  		})
  
  		self._charset = 'x-user-defined'
  		if (!capability.overrideMimeType) {
  			var mimeType = self.rawHeaders['mime-type']
  			if (mimeType) {
  				var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/)
  				if (charsetMatch) {
  					self._charset = charsetMatch[1].toLowerCase()
  				}
  			}
  			if (!self._charset)
  				self._charset = 'utf-8' // best guess
  		}
  	}
  }
  
  inherits(IncomingMessage, stream.Readable)
  
  IncomingMessage.prototype._read = function () {
  	var self = this
  
  	var resolve = self._resumeFetch
  	if (resolve) {
  		self._resumeFetch = null
  		resolve()
  	}
  }
  
  IncomingMessage.prototype._onXHRProgress = function () {
  	var self = this
  
  	var xhr = self._xhr
  
  	var response = null
  	switch (self._mode) {
  		case 'text:vbarray': // For IE9
  			if (xhr.readyState !== rStates.DONE)
  				break
  			try {
  				// This fails in IE8
  				response = new global.VBArray(xhr.responseBody).toArray()
  			} catch (e) {}
  			if (response !== null) {
  				self.push(new Buffer(response))
  				break
  			}
  			// Falls through in IE8	
  		case 'text':
  			try { // This will fail when readyState = 3 in IE9. Switch mode and wait for readyState = 4
  				response = xhr.responseText
  			} catch (e) {
  				self._mode = 'text:vbarray'
  				break
  			}
  			if (response.length > self._pos) {
  				var newData = response.substr(self._pos)
  				if (self._charset === 'x-user-defined') {
  					var buffer = new Buffer(newData.length)
  					for (var i = 0; i < newData.length; i++)
  						buffer[i] = newData.charCodeAt(i) & 0xff
  
  					self.push(buffer)
  				} else {
  					self.push(newData, self._charset)
  				}
  				self._pos = response.length
  			}
  			break
  		case 'arraybuffer':
  			if (xhr.readyState !== rStates.DONE || !xhr.response)
  				break
  			response = xhr.response
  			self.push(new Buffer(new Uint8Array(response)))
  			break
  		case 'moz-chunked-arraybuffer': // take whole
  			response = xhr.response
  			if (xhr.readyState !== rStates.LOADING || !response)
  				break
  			self.push(new Buffer(new Uint8Array(response)))
  			break
  		case 'ms-stream':
  			response = xhr.response
  			if (xhr.readyState !== rStates.LOADING)
  				break
  			var reader = new global.MSStreamReader()
  			reader.onprogress = function () {
  				if (reader.result.byteLength > self._pos) {
  					self.push(new Buffer(new Uint8Array(reader.result.slice(self._pos))))
  					self._pos = reader.result.byteLength
  				}
  			}
  			reader.onload = function () {
  				self.push(null)
  			}
  			// reader.onerror = ??? // TODO: this
  			reader.readAsArrayBuffer(response)
  			break
  	}
  
  	// The ms-stream case handles end separately in reader.onload()
  	if (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {
  		self.push(null)
  	}
  }
  
  }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
  
  },{"./capability":118,"_process":101,"buffer":55,"inherits":96,"readable-stream":115}],121:[function(require,module,exports){
  (function (setImmediate,clearImmediate){
  var nextTick = require('process/browser.js').nextTick;
  var apply = Function.prototype.apply;
  var slice = Array.prototype.slice;
  var immediateIds = {};
  var nextImmediateId = 0;
  
  // DOM APIs, for completeness
  
  exports.setTimeout = function() {
    return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
  };
  exports.setInterval = function() {
    return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
  };
  exports.clearTimeout =
  exports.clearInterval = function(timeout) { timeout.close(); };
  
  function Timeout(id, clearFn) {
    this._id = id;
    this._clearFn = clearFn;
  }
  Timeout.prototype.unref = Timeout.prototype.ref = function() {};
  Timeout.prototype.close = function() {
    this._clearFn.call(window, this._id);
  };
  
  // Does not start the time, just sets up the members needed.
  exports.enroll = function(item, msecs) {
    clearTimeout(item._idleTimeoutId);
    item._idleTimeout = msecs;
  };
  
  exports.unenroll = function(item) {
    clearTimeout(item._idleTimeoutId);
    item._idleTimeout = -1;
  };
  
  exports._unrefActive = exports.active = function(item) {
    clearTimeout(item._idleTimeoutId);
  
    var msecs = item._idleTimeout;
    if (msecs >= 0) {
      item._idleTimeoutId = setTimeout(function onTimeout() {
        if (item._onTimeout)
          item._onTimeout();
      }, msecs);
    }
  };
  
  // That's not how node.js implements it but the exposed api is the same.
  exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
    var id = nextImmediateId++;
    var args = arguments.length < 2 ? false : slice.call(arguments, 1);
  
    immediateIds[id] = true;
  
    nextTick(function onNextTick() {
      if (immediateIds[id]) {
        // fn.call() is faster so we optimize for the common use-case
        // @see http://jsperf.com/call-apply-segu
        if (args) {
          fn.apply(null, args);
        } else {
          fn.call(null);
        }
        // Prevent ids from leaking
        exports.clearImmediate(id);
      }
    });
  
    return id;
  };
  
  exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
    delete immediateIds[id];
  };
  }).call(this,require("timers").setImmediate,require("timers").clearImmediate)
  
  },{"process/browser.js":101,"timers":121}],122:[function(require,module,exports){
  var Buffer = require('buffer').Buffer
  
  module.exports = function (buf) {
  	// If the buffer is backed by a Uint8Array, a faster version will work
  	if (buf instanceof Uint8Array) {
  		// If the buffer isn't a subarray, return the underlying ArrayBuffer
  		if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
  			return buf.buffer
  		} else if (typeof buf.buffer.slice === 'function') {
  			// Otherwise we need to get a proper copy
  			return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
  		}
  	}
  
  	if (Buffer.isBuffer(buf)) {
  		// This is the slow version that will work with any Buffer
  		// implementation (even in old browsers)
  		var arrayCopy = new Uint8Array(buf.length)
  		var len = buf.length
  		for (var i = 0; i < len; i++) {
  			arrayCopy[i] = buf[i]
  		}
  		return arrayCopy.buffer
  	} else {
  		throw new Error('Argument must be a Buffer')
  	}
  }
  
  },{"buffer":55}],123:[function(require,module,exports){
  // 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.
  
  'use strict';
  
  var punycode = require('punycode');
  var util = require('./util');
  
  exports.parse = urlParse;
  exports.resolve = urlResolve;
  exports.resolveObject = urlResolveObject;
  exports.format = urlFormat;
  
  exports.Url = Url;
  
  function Url() {
    this.protocol = null;
    this.slashes = null;
    this.auth = null;
    this.host = null;
    this.port = null;
    this.hostname = null;
    this.hash = null;
    this.search = null;
    this.query = null;
    this.pathname = null;
    this.path = null;
    this.href = null;
  }
  
  // Reference: RFC 3986, RFC 1808, RFC 2396
  
  // define these here so at least they only have to be
  // compiled once on the first module load.
  var protocolPattern = /^([a-z0-9.+-]+:)/i,
      portPattern = /:[0-9]*$/,
  
      // Special case for a simple path URL
      simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
  
      // RFC 2396: characters reserved for delimiting URLs.
      // We actually just auto-escape these.
      delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
  
      // RFC 2396: characters not allowed for various reasons.
      unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
  
      // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
      autoEscape = ['\''].concat(unwise),
      // Characters that are never ever allowed in a hostname.
      // Note that any invalid chars are also handled, but these
      // are the ones that are *expected* to be seen, so we fast-path
      // them.
      nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
      hostEndingChars = ['/', '?', '#'],
      hostnameMaxLen = 255,
      hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
      hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
      // protocols that can allow "unsafe" and "unwise" chars.
      unsafeProtocol = {
        'javascript': true,
        'javascript:': true
      },
      // protocols that never have a hostname.
      hostlessProtocol = {
        'javascript': true,
        'javascript:': true
      },
      // protocols that always contain a // bit.
      slashedProtocol = {
        'http': true,
        'https': true,
        'ftp': true,
        'gopher': true,
        'file': true,
        'http:': true,
        'https:': true,
        'ftp:': true,
        'gopher:': true,
        'file:': true
      },
      querystring = require('querystring');
  
  function urlParse(url, parseQueryString, slashesDenoteHost) {
    if (url && util.isObject(url) && url instanceof Url) return url;
  
    var u = new Url;
    u.parse(url, parseQueryString, slashesDenoteHost);
    return u;
  }
  
  Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
    if (!util.isString(url)) {
      throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
    }
  
    // Copy chrome, IE, opera backslash-handling behavior.
    // Back slashes before the query string get converted to forward slashes
    // See: https://code.google.com/p/chromium/issues/detail?id=25916
    var queryIndex = url.indexOf('?'),
        splitter =
            (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
        uSplit = url.split(splitter),
        slashRegex = /\\/g;
    uSplit[0] = uSplit[0].replace(slashRegex, '/');
    url = uSplit.join(splitter);
  
    var rest = url;
  
    // trim before proceeding.
    // This is to support parse stuff like "  http://foo.com  \n"
    rest = rest.trim();
  
    if (!slashesDenoteHost && url.split('#').length === 1) {
      // Try fast path regexp
      var simplePath = simplePathPattern.exec(rest);
      if (simplePath) {
        this.path = rest;
        this.href = rest;
        this.pathname = simplePath[1];
        if (simplePath[2]) {
          this.search = simplePath[2];
          if (parseQueryString) {
            this.query = querystring.parse(this.search.substr(1));
          } else {
            this.query = this.search.substr(1);
          }
        } else if (parseQueryString) {
          this.search = '';
          this.query = {};
        }
        return this;
      }
    }
  
    var proto = protocolPattern.exec(rest);
    if (proto) {
      proto = proto[0];
      var lowerProto = proto.toLowerCase();
      this.protocol = lowerProto;
      rest = rest.substr(proto.length);
    }
  
    // figure out if it's got a host
    // user@server is *always* interpreted as a hostname, and url
    // resolution will treat //foo/bar as host=foo,path=bar because that's
    // how the browser resolves relative URLs.
    if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
      var slashes = rest.substr(0, 2) === '//';
      if (slashes && !(proto && hostlessProtocol[proto])) {
        rest = rest.substr(2);
        this.slashes = true;
      }
    }
  
    if (!hostlessProtocol[proto] &&
        (slashes || (proto && !slashedProtocol[proto]))) {
  
      // there's a hostname.
      // the first instance of /, ?, ;, or # ends the host.
      //
      // If there is an @ in the hostname, then non-host chars *are* allowed
      // to the left of the last @ sign, unless some host-ending character
      // comes *before* the @-sign.
      // URLs are obnoxious.
      //
      // ex:
      // http://a@b@c/ => user:a@b host:c
      // http://a@b?@c => user:a host:c path:/?@c
  
      // v0.12 TODO(isaacs): This is not quite how Chrome does things.
      // Review our test case against browsers more comprehensively.
  
      // find the first instance of any hostEndingChars
      var hostEnd = -1;
      for (var i = 0; i < hostEndingChars.length; i++) {
        var hec = rest.indexOf(hostEndingChars[i]);
        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
          hostEnd = hec;
      }
  
      // at this point, either we have an explicit point where the
      // auth portion cannot go past, or the last @ char is the decider.
      var auth, atSign;
      if (hostEnd === -1) {
        // atSign can be anywhere.
        atSign = rest.lastIndexOf('@');
      } else {
        // atSign must be in auth portion.
        // http://a@b/c@d => host:b auth:a path:/c@d
        atSign = rest.lastIndexOf('@', hostEnd);
      }
  
      // Now we have a portion which is definitely the auth.
      // Pull that off.
      if (atSign !== -1) {
        auth = rest.slice(0, atSign);
        rest = rest.slice(atSign + 1);
        this.auth = decodeURIComponent(auth);
      }
  
      // the host is the remaining to the left of the first non-host char
      hostEnd = -1;
      for (var i = 0; i < nonHostChars.length; i++) {
        var hec = rest.indexOf(nonHostChars[i]);
        if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
          hostEnd = hec;
      }
      // if we still have not hit it, then the entire thing is a host.
      if (hostEnd === -1)
        hostEnd = rest.length;
  
      this.host = rest.slice(0, hostEnd);
      rest = rest.slice(hostEnd);
  
      // pull out port.
      this.parseHost();
  
      // we've indicated that there is a hostname,
      // so even if it's empty, it has to be present.
      this.hostname = this.hostname || '';
  
      // if hostname begins with [ and ends with ]
      // assume that it's an IPv6 address.
      var ipv6Hostname = this.hostname[0] === '[' &&
          this.hostname[this.hostname.length - 1] === ']';
  
      // validate a little.
      if (!ipv6Hostname) {
        var hostparts = this.hostname.split(/\./);
        for (var i = 0, l = hostparts.length; i < l; i++) {
          var part = hostparts[i];
          if (!part) continue;
          if (!part.match(hostnamePartPattern)) {
            var newpart = '';
            for (var j = 0, k = part.length; j < k; j++) {
              if (part.charCodeAt(j) > 127) {
                // we replace non-ASCII char with a temporary placeholder
                // we need this to make sure size of hostname is not
                // broken by replacing non-ASCII by nothing
                newpart += 'x';
              } else {
                newpart += part[j];
              }
            }
            // we test again with ASCII char only
            if (!newpart.match(hostnamePartPattern)) {
              var validParts = hostparts.slice(0, i);
              var notHost = hostparts.slice(i + 1);
              var bit = part.match(hostnamePartStart);
              if (bit) {
                validParts.push(bit[1]);
                notHost.unshift(bit[2]);
              }
              if (notHost.length) {
                rest = '/' + notHost.join('.') + rest;
              }
              this.hostname = validParts.join('.');
              break;
            }
          }
        }
      }
  
      if (this.hostname.length > hostnameMaxLen) {
        this.hostname = '';
      } else {
        // hostnames are always lower case.
        this.hostname = this.hostname.toLowerCase();
      }
  
      if (!ipv6Hostname) {
        // IDNA Support: Returns a punycoded representation of "domain".
        // It only converts parts of the domain name that
        // have non-ASCII characters, i.e. it doesn't matter if
        // you call it with a domain that already is ASCII-only.
        this.hostname = punycode.toASCII(this.hostname);
      }
  
      var p = this.port ? ':' + this.port : '';
      var h = this.hostname || '';
      this.host = h + p;
      this.href += this.host;
  
      // strip [ and ] from the hostname
      // the host field still retains them, though
      if (ipv6Hostname) {
        this.hostname = this.hostname.substr(1, this.hostname.length - 2);
        if (rest[0] !== '/') {
          rest = '/' + rest;
        }
      }
    }
  
    // now rest is set to the post-host stuff.
    // chop off any delim chars.
    if (!unsafeProtocol[lowerProto]) {
  
      // First, make 100% sure that any "autoEscape" chars get
      // escaped, even if encodeURIComponent doesn't think they
      // need to be.
      for (var i = 0, l = autoEscape.length; i < l; i++) {
        var ae = autoEscape[i];
        if (rest.indexOf(ae) === -1)
          continue;
        var esc = encodeURIComponent(ae);
        if (esc === ae) {
          esc = escape(ae);
        }
        rest = rest.split(ae).join(esc);
      }
    }
  
  
    // chop off from the tail first.
    var hash = rest.indexOf('#');
    if (hash !== -1) {
      // got a fragment string.
      this.hash = rest.substr(hash);
      rest = rest.slice(0, hash);
    }
    var qm = rest.indexOf('?');
    if (qm !== -1) {
      this.search = rest.substr(qm);
      this.query = rest.substr(qm + 1);
      if (parseQueryString) {
        this.query = querystring.parse(this.query);
      }
      rest = rest.slice(0, qm);
    } else if (parseQueryString) {
      // no query string, but parseQueryString still requested
      this.search = '';
      this.query = {};
    }
    if (rest) this.pathname = rest;
    if (slashedProtocol[lowerProto] &&
        this.hostname && !this.pathname) {
      this.pathname = '/';
    }
  
    //to support http.request
    if (this.pathname || this.search) {
      var p = this.pathname || '';
      var s = this.search || '';
      this.path = p + s;
    }
  
    // finally, reconstruct the href based on what has been validated.
    this.href = this.format();
    return this;
  };
  
  // format a parsed object into a url string
  function urlFormat(obj) {
    // ensure it's an object, and not a string url.
    // If it's an obj, this is a no-op.
    // this way, you can call url_format() on strings
    // to clean up potentially wonky urls.
    if (util.isString(obj)) obj = urlParse(obj);
    if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
    return obj.format();
  }
  
  Url.prototype.format = function() {
    var auth = this.auth || '';
    if (auth) {
      auth = encodeURIComponent(auth);
      auth = auth.replace(/%3A/i, ':');
      auth += '@';
    }
  
    var protocol = this.protocol || '',
        pathname = this.pathname || '',
        hash = this.hash || '',
        host = false,
        query = '';
  
    if (this.host) {
      host = auth + this.host;
    } else if (this.hostname) {
      host = auth + (this.hostname.indexOf(':') === -1 ?
          this.hostname :
          '[' + this.hostname + ']');
      if (this.port) {
        host += ':' + this.port;
      }
    }
  
    if (this.query &&
        util.isObject(this.query) &&
        Object.keys(this.query).length) {
      query = querystring.stringify(this.query);
    }
  
    var search = this.search || (query && ('?' + query)) || '';
  
    if (protocol && protocol.substr(-1) !== ':') protocol += ':';
  
    // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
    // unless they had them to begin with.
    if (this.slashes ||
        (!protocol || slashedProtocol[protocol]) && host !== false) {
      host = '//' + (host || '');
      if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
    } else if (!host) {
      host = '';
    }
  
    if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
    if (search && search.charAt(0) !== '?') search = '?' + search;
  
    pathname = pathname.replace(/[?#]/g, function(match) {
      return encodeURIComponent(match);
    });
    search = search.replace('#', '%23');
  
    return protocol + host + pathname + search + hash;
  };
  
  function urlResolve(source, relative) {
    return urlParse(source, false, true).resolve(relative);
  }
  
  Url.prototype.resolve = function(relative) {
    return this.resolveObject(urlParse(relative, false, true)).format();
  };
  
  function urlResolveObject(source, relative) {
    if (!source) return relative;
    return urlParse(source, false, true).resolveObject(relative);
  }
  
  Url.prototype.resolveObject = function(relative) {
    if (util.isString(relative)) {
      var rel = new Url();
      rel.parse(relative, false, true);
      relative = rel;
    }
  
    var result = new Url();
    var tkeys = Object.keys(this);
    for (var tk = 0; tk < tkeys.length; tk++) {
      var tkey = tkeys[tk];
      result[tkey] = this[tkey];
    }
  
    // hash is always overridden, no matter what.
    // even href="" will remove it.
    result.hash = relative.hash;
  
    // if the relative url is empty, then there's nothing left to do here.
    if (relative.href === '') {
      result.href = result.format();
      return result;
    }
  
    // hrefs like //foo/bar always cut to the protocol.
    if (relative.slashes && !relative.protocol) {
      // take everything except the protocol from relative
      var rkeys = Object.keys(relative);
      for (var rk = 0; rk < rkeys.length; rk++) {
        var rkey = rkeys[rk];
        if (rkey !== 'protocol')
          result[rkey] = relative[rkey];
      }
  
      //urlParse appends trailing / to urls like http://www.example.com
      if (slashedProtocol[result.protocol] &&
          result.hostname && !result.pathname) {
        result.path = result.pathname = '/';
      }
  
      result.href = result.format();
      return result;
    }
  
    if (relative.protocol && relative.protocol !== result.protocol) {
      // if it's a known url protocol, then changing
      // the protocol does weird things
      // first, if it's not file:, then we MUST have a host,
      // and if there was a path
      // to begin with, then we MUST have a path.
      // if it is file:, then the host is dropped,
      // because that's known to be hostless.
      // anything else is assumed to be absolute.
      if (!slashedProtocol[relative.protocol]) {
        var keys = Object.keys(relative);
        for (var v = 0; v < keys.length; v++) {
          var k = keys[v];
          result[k] = relative[k];
        }
        result.href = result.format();
        return result;
      }
  
      result.protocol = relative.protocol;
      if (!relative.host && !hostlessProtocol[relative.protocol]) {
        var relPath = (relative.pathname || '').split('/');
        while (relPath.length && !(relative.host = relPath.shift()));
        if (!relative.host) relative.host = '';
        if (!relative.hostname) relative.hostname = '';
        if (relPath[0] !== '') relPath.unshift('');
        if (relPath.length < 2) relPath.unshift('');
        result.pathname = relPath.join('/');
      } else {
        result.pathname = relative.pathname;
      }
      result.search = relative.search;
      result.query = relative.query;
      result.host = relative.host || '';
      result.auth = relative.auth;
      result.hostname = relative.hostname || relative.host;
      result.port = relative.port;
      // to support http.request
      if (result.pathname || result.search) {
        var p = result.pathname || '';
        var s = result.search || '';
        result.path = p + s;
      }
      result.slashes = result.slashes || relative.slashes;
      result.href = result.format();
      return result;
    }
  
    var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
        isRelAbs = (
            relative.host ||
            relative.pathname && relative.pathname.charAt(0) === '/'
        ),
        mustEndAbs = (isRelAbs || isSourceAbs ||
                      (result.host && relative.pathname)),
        removeAllDots = mustEndAbs,
        srcPath = result.pathname && result.pathname.split('/') || [],
        relPath = relative.pathname && relative.pathname.split('/') || [],
        psychotic = result.protocol && !slashedProtocol[result.protocol];
  
    // if the url is a non-slashed url, then relative
    // links like ../.. should be able
    // to crawl up to the hostname, as well.  This is strange.
    // result.protocol has already been set by now.
    // Later on, put the first path part into the host field.
    if (psychotic) {
      result.hostname = '';
      result.port = null;
      if (result.host) {
        if (srcPath[0] === '') srcPath[0] = result.host;
        else srcPath.unshift(result.host);
      }
      result.host = '';
      if (relative.protocol) {
        relative.hostname = null;
        relative.port = null;
        if (relative.host) {
          if (relPath[0] === '') relPath[0] = relative.host;
          else relPath.unshift(relative.host);
        }
        relative.host = null;
      }
      mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
    }
  
    if (isRelAbs) {
      // it's absolute.
      result.host = (relative.host || relative.host === '') ?
                    relative.host : result.host;
      result.hostname = (relative.hostname || relative.hostname === '') ?
                        relative.hostname : result.hostname;
      result.search = relative.search;
      result.query = relative.query;
      srcPath = relPath;
      // fall through to the dot-handling below.
    } else if (relPath.length) {
      // it's relative
      // throw away the existing file, and take the new path instead.
      if (!srcPath) srcPath = [];
      srcPath.pop();
      srcPath = srcPath.concat(relPath);
      result.search = relative.search;
      result.query = relative.query;
    } else if (!util.isNullOrUndefined(relative.search)) {
      // just pull out the search.
      // like href='?foo'.
      // Put this after the other two cases because it simplifies the booleans
      if (psychotic) {
        result.hostname = result.host = srcPath.shift();
        //occationaly the auth can get stuck only in host
        //this especially happens in cases like
        //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
        var authInHost = result.host && result.host.indexOf('@') > 0 ?
                         result.host.split('@') : false;
        if (authInHost) {
          result.auth = authInHost.shift();
          result.host = result.hostname = authInHost.shift();
        }
      }
      result.search = relative.search;
      result.query = relative.query;
      //to support http.request
      if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
        result.path = (result.pathname ? result.pathname : '') +
                      (result.search ? result.search : '');
      }
      result.href = result.format();
      return result;
    }
  
    if (!srcPath.length) {
      // no path at all.  easy.
      // we've already handled the other stuff above.
      result.pathname = null;
      //to support http.request
      if (result.search) {
        result.path = '/' + result.search;
      } else {
        result.path = null;
      }
      result.href = result.format();
      return result;
    }
  
    // if a url ENDs in . or .., then it must get a trailing slash.
    // however, if it ends in anything else non-slashy,
    // then it must NOT get a trailing slash.
    var last = srcPath.slice(-1)[0];
    var hasTrailingSlash = (
        (result.host || relative.host || srcPath.length > 1) &&
        (last === '.' || last === '..') || last === '');
  
    // strip single dots, resolve double dots to parent dir
    // if the path tries to go above the root, `up` ends up > 0
    var up = 0;
    for (var i = srcPath.length; i >= 0; i--) {
      last = srcPath[i];
      if (last === '.') {
        srcPath.splice(i, 1);
      } else if (last === '..') {
        srcPath.splice(i, 1);
        up++;
      } else if (up) {
        srcPath.splice(i, 1);
        up--;
      }
    }
  
    // if the path is allowed to go above the root, restore leading ..s
    if (!mustEndAbs && !removeAllDots) {
      for (; up--; up) {
        srcPath.unshift('..');
      }
    }
  
    if (mustEndAbs && srcPath[0] !== '' &&
        (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
      srcPath.unshift('');
    }
  
    if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
      srcPath.push('');
    }
  
    var isAbsolute = srcPath[0] === '' ||
        (srcPath[0] && srcPath[0].charAt(0) === '/');
  
    // put the host back
    if (psychotic) {
      result.hostname = result.host = isAbsolute ? '' :
                                      srcPath.length ? srcPath.shift() : '';
      //occationaly the auth can get stuck only in host
      //this especially happens in cases like
      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')
      var authInHost = result.host && result.host.indexOf('@') > 0 ?
                       result.host.split('@') : false;
      if (authInHost) {
        result.auth = authInHost.shift();
        result.host = result.hostname = authInHost.shift();
      }
    }
  
    mustEndAbs = mustEndAbs || (result.host && srcPath.length);
  
    if (mustEndAbs && !isAbsolute) {
      srcPath.unshift('');
    }
  
    if (!srcPath.length) {
      result.pathname = null;
      result.path = null;
    } else {
      result.pathname = srcPath.join('/');
    }
  
    //to support request.http
    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
      result.path = (result.pathname ? result.pathname : '') +
                    (result.search ? result.search : '');
    }
    result.auth = relative.auth || result.auth;
    result.slashes = result.slashes || relative.slashes;
    result.href = result.format();
    return result;
  };
  
  Url.prototype.parseHost = function() {
    var host = this.host;
    var port = portPattern.exec(host);
    if (port) {
      port = port[0];
      if (port !== ':') {
        this.port = port.substr(1);
      }
      host = host.substr(0, host.length - port.length);
    }
    if (host) this.hostname = host;
  };
  
  },{"./util":124,"punycode":102,"querystring":105}],124:[function(require,module,exports){
  'use strict';
  
  module.exports = {
    isString: function(arg) {
      return typeof(arg) === 'string';
    },
    isObject: function(arg) {
      return typeof(arg) === 'object' && arg !== null;
    },
    isNull: function(arg) {
      return arg === null;
    },
    isNullOrUndefined: function(arg) {
      return arg == null;
    }
  };
  
  },{}],125:[function(require,module,exports){
  (function (global){
  /*! https://mths.be/utf8js v2.1.2 by @mathias */
  ;(function(root) {
  
  	// Detect free variables `exports`
  	var freeExports = typeof exports == 'object' && exports;
  
  	// Detect free variable `module`
  	var freeModule = typeof module == 'object' && module &&
  		module.exports == freeExports && module;
  
  	// Detect free variable `global`, from Node.js or Browserified code,
  	// and use it as `root`
  	var freeGlobal = typeof global == 'object' && global;
  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
  		root = freeGlobal;
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	var stringFromCharCode = String.fromCharCode;
  
  	// Taken from https://mths.be/punycode
  	function ucs2decode(string) {
  		var output = [];
  		var counter = 0;
  		var length = string.length;
  		var value;
  		var extra;
  		while (counter < length) {
  			value = string.charCodeAt(counter++);
  			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
  				// high surrogate, and there is a next character
  				extra = string.charCodeAt(counter++);
  				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
  					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
  				} else {
  					// unmatched surrogate; only append this code unit, in case the next
  					// code unit is the high surrogate of a surrogate pair
  					output.push(value);
  					counter--;
  				}
  			} else {
  				output.push(value);
  			}
  		}
  		return output;
  	}
  
  	// Taken from https://mths.be/punycode
  	function ucs2encode(array) {
  		var length = array.length;
  		var index = -1;
  		var value;
  		var output = '';
  		while (++index < length) {
  			value = array[index];
  			if (value > 0xFFFF) {
  				value -= 0x10000;
  				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
  				value = 0xDC00 | value & 0x3FF;
  			}
  			output += stringFromCharCode(value);
  		}
  		return output;
  	}
  
  	function checkScalarValue(codePoint) {
  		if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
  			throw Error(
  				'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
  				' is not a scalar value'
  			);
  		}
  	}
  	/*--------------------------------------------------------------------------*/
  
  	function createByte(codePoint, shift) {
  		return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
  	}
  
  	function encodeCodePoint(codePoint) {
  		if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
  			return stringFromCharCode(codePoint);
  		}
  		var symbol = '';
  		if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
  			symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
  		}
  		else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
  			checkScalarValue(codePoint);
  			symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
  			symbol += createByte(codePoint, 6);
  		}
  		else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
  			symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
  			symbol += createByte(codePoint, 12);
  			symbol += createByte(codePoint, 6);
  		}
  		symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
  		return symbol;
  	}
  
  	function utf8encode(string) {
  		var codePoints = ucs2decode(string);
  		var length = codePoints.length;
  		var index = -1;
  		var codePoint;
  		var byteString = '';
  		while (++index < length) {
  			codePoint = codePoints[index];
  			byteString += encodeCodePoint(codePoint);
  		}
  		return byteString;
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	function readContinuationByte() {
  		if (byteIndex >= byteCount) {
  			throw Error('Invalid byte index');
  		}
  
  		var continuationByte = byteArray[byteIndex] & 0xFF;
  		byteIndex++;
  
  		if ((continuationByte & 0xC0) == 0x80) {
  			return continuationByte & 0x3F;
  		}
  
  		// If we end up here, it’s not a continuation byte
  		throw Error('Invalid continuation byte');
  	}
  
  	function decodeSymbol() {
  		var byte1;
  		var byte2;
  		var byte3;
  		var byte4;
  		var codePoint;
  
  		if (byteIndex > byteCount) {
  			throw Error('Invalid byte index');
  		}
  
  		if (byteIndex == byteCount) {
  			return false;
  		}
  
  		// Read first byte
  		byte1 = byteArray[byteIndex] & 0xFF;
  		byteIndex++;
  
  		// 1-byte sequence (no continuation bytes)
  		if ((byte1 & 0x80) == 0) {
  			return byte1;
  		}
  
  		// 2-byte sequence
  		if ((byte1 & 0xE0) == 0xC0) {
  			byte2 = readContinuationByte();
  			codePoint = ((byte1 & 0x1F) << 6) | byte2;
  			if (codePoint >= 0x80) {
  				return codePoint;
  			} else {
  				throw Error('Invalid continuation byte');
  			}
  		}
  
  		// 3-byte sequence (may include unpaired surrogates)
  		if ((byte1 & 0xF0) == 0xE0) {
  			byte2 = readContinuationByte();
  			byte3 = readContinuationByte();
  			codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
  			if (codePoint >= 0x0800) {
  				checkScalarValue(codePoint);
  				return codePoint;
  			} else {
  				throw Error('Invalid continuation byte');
  			}
  		}
  
  		// 4-byte sequence
  		if ((byte1 & 0xF8) == 0xF0) {
  			byte2 = readContinuationByte();
  			byte3 = readContinuationByte();
  			byte4 = readContinuationByte();
  			codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
  				(byte3 << 0x06) | byte4;
  			if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
  				return codePoint;
  			}
  		}
  
  		throw Error('Invalid UTF-8 detected');
  	}
  
  	var byteArray;
  	var byteCount;
  	var byteIndex;
  	function utf8decode(byteString) {
  		byteArray = ucs2decode(byteString);
  		byteCount = byteArray.length;
  		byteIndex = 0;
  		var codePoints = [];
  		var tmp;
  		while ((tmp = decodeSymbol()) !== false) {
  			codePoints.push(tmp);
  		}
  		return ucs2encode(codePoints);
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	var utf8 = {
  		'version': '2.1.2',
  		'encode': utf8encode,
  		'decode': utf8decode
  	};
  
  	// Some AMD build optimizers, like r.js, check for specific condition patterns
  	// like the following:
  	if (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define(function() {
  			return utf8;
  		});
  	}	else if (freeExports && !freeExports.nodeType) {
  		if (freeModule) { // in Node.js or RingoJS v0.8.0+
  			freeModule.exports = utf8;
  		} else { // in Narwhal or RingoJS v0.7.0-
  			var object = {};
  			var hasOwnProperty = object.hasOwnProperty;
  			for (var key in utf8) {
  				hasOwnProperty.call(utf8, key) && (freeExports[key] = utf8[key]);
  			}
  		}
  	} else { // in Rhino or a web browser
  		root.utf8 = utf8;
  	}
  
  }(this));
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{}],126:[function(require,module,exports){
  (function (global){
  
  /**
   * Module exports.
   */
  
  module.exports = deprecate;
  
  /**
   * Mark that a method should not be used.
   * Returns a modified function which warns once by default.
   *
   * If `localStorage.noDeprecation = true` is set, then it is a no-op.
   *
   * If `localStorage.throwDeprecation = true` is set, then deprecated functions
   * will throw an Error when invoked.
   *
   * If `localStorage.traceDeprecation = true` is set, then deprecated functions
   * will invoke `console.trace()` instead of `console.error()`.
   *
   * @param {Function} fn - the function to deprecate
   * @param {String} msg - the string to print to the console when `fn` is invoked
   * @returns {Function} a new "deprecated" version of `fn`
   * @api public
   */
  
  function deprecate (fn, msg) {
    if (config('noDeprecation')) {
      return fn;
    }
  
    var warned = false;
    function deprecated() {
      if (!warned) {
        if (config('throwDeprecation')) {
          throw new Error(msg);
        } else if (config('traceDeprecation')) {
          console.trace(msg);
        } else {
          console.warn(msg);
        }
        warned = true;
      }
      return fn.apply(this, arguments);
    }
  
    return deprecated;
  }
  
  /**
   * Checks `localStorage` for boolean values for the given `name`.
   *
   * @param {String} name
   * @returns {Boolean}
   * @api private
   */
  
  function config (name) {
    // accessing global.localStorage can trigger a DOMException in sandboxed iframes
    try {
      if (!global.localStorage) return false;
    } catch (_) {
      return false;
    }
    var val = global.localStorage[name];
    if (null == val) return false;
    return String(val).toLowerCase() === 'true';
  }
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  
  },{}],127:[function(require,module,exports){
  "use strict";
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, "__esModule", { value: true });
  var SecurityError = /** @class */ (function (_super) {
      __extends(SecurityError, _super);
      function SecurityError() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return SecurityError;
  }(Error));
  exports.SecurityError = SecurityError;
  var InvalidStateError = /** @class */ (function (_super) {
      __extends(InvalidStateError, _super);
      function InvalidStateError() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return InvalidStateError;
  }(Error));
  exports.InvalidStateError = InvalidStateError;
  var NetworkError = /** @class */ (function (_super) {
      __extends(NetworkError, _super);
      function NetworkError() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return NetworkError;
  }(Error));
  exports.NetworkError = NetworkError;
  var SyntaxError = /** @class */ (function (_super) {
      __extends(SyntaxError, _super);
      function SyntaxError() {
          return _super !== null && _super.apply(this, arguments) || this;
      }
      return SyntaxError;
  }(Error));
  exports.SyntaxError = SyntaxError;
  
  },{}],128:[function(require,module,exports){
  "use strict";
  function __export(m) {
      for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
  }
  Object.defineProperty(exports, "__esModule", { value: true });
  __export(require("./xml-http-request"));
  var xml_http_request_event_target_1 = require("./xml-http-request-event-target");
  exports.XMLHttpRequestEventTarget = xml_http_request_event_target_1.XMLHttpRequestEventTarget;
  
  },{"./xml-http-request":132,"./xml-http-request-event-target":130}],129:[function(require,module,exports){
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  var ProgressEvent = /** @class */ (function () {
      function ProgressEvent(type) {
          this.type = type;
          this.bubbles = false;
          this.cancelable = false;
          this.loaded = 0;
          this.lengthComputable = false;
          this.total = 0;
      }
      return ProgressEvent;
  }());
  exports.ProgressEvent = ProgressEvent;
  
  },{}],130:[function(require,module,exports){
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  var XMLHttpRequestEventTarget = /** @class */ (function () {
      function XMLHttpRequestEventTarget() {
          this.listeners = {};
      }
      XMLHttpRequestEventTarget.prototype.addEventListener = function (eventType, listener) {
          eventType = eventType.toLowerCase();
          this.listeners[eventType] = this.listeners[eventType] || [];
          this.listeners[eventType].push(listener.handleEvent || listener);
      };
      XMLHttpRequestEventTarget.prototype.removeEventListener = function (eventType, listener) {
          eventType = eventType.toLowerCase();
          if (!this.listeners[eventType]) {
              return;
          }
          var index = this.listeners[eventType].indexOf(listener.handleEvent || listener);
          if (index < 0) {
              return;
          }
          this.listeners[eventType].splice(index, 1);
      };
      XMLHttpRequestEventTarget.prototype.dispatchEvent = function (event) {
          var eventType = event.type.toLowerCase();
          event.target = this; // TODO: set event.currentTarget?
          if (this.listeners[eventType]) {
              for (var _i = 0, _a = this.listeners[eventType]; _i < _a.length; _i++) {
                  var listener_1 = _a[_i];
                  listener_1.call(this, event);
              }
          }
          var listener = this["on" + eventType];
          if (listener) {
              listener.call(this, event);
          }
          return true;
      };
      return XMLHttpRequestEventTarget;
  }());
  exports.XMLHttpRequestEventTarget = XMLHttpRequestEventTarget;
  
  },{}],131:[function(require,module,exports){
  (function (Buffer){
  "use strict";
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  Object.defineProperty(exports, "__esModule", { value: true });
  var xml_http_request_event_target_1 = require("./xml-http-request-event-target");
  var XMLHttpRequestUpload = /** @class */ (function (_super) {
      __extends(XMLHttpRequestUpload, _super);
      function XMLHttpRequestUpload() {
          var _this = _super.call(this) || this;
          _this._contentType = null;
          _this._body = null;
          _this._reset();
          return _this;
      }
      XMLHttpRequestUpload.prototype._reset = function () {
          this._contentType = null;
          this._body = null;
      };
      XMLHttpRequestUpload.prototype._setData = function (data) {
          if (data == null) {
              return;
          }
          if (typeof data === 'string') {
              if (data.length !== 0) {
                  this._contentType = 'text/plain;charset=UTF-8';
              }
              this._body = new Buffer(data, 'utf-8');
          }
          else if (Buffer.isBuffer(data)) {
              this._body = data;
          }
          else if (data instanceof ArrayBuffer) {
              var body = new Buffer(data.byteLength);
              var view = new Uint8Array(data);
              for (var i = 0; i < data.byteLength; i++) {
                  body[i] = view[i];
              }
              this._body = body;
          }
          else if (data.buffer && data.buffer instanceof ArrayBuffer) {
              var body = new Buffer(data.byteLength);
              var offset = data.byteOffset;
              var view = new Uint8Array(data.buffer);
              for (var i = 0; i < data.byteLength; i++) {
                  body[i] = view[i + offset];
              }
              this._body = body;
          }
          else {
              throw new Error("Unsupported send() data " + data);
          }
      };
      XMLHttpRequestUpload.prototype._finalizeHeaders = function (headers, loweredHeaders) {
          if (this._contentType && !loweredHeaders['content-type']) {
              headers['Content-Type'] = this._contentType;
          }
          if (this._body) {
              headers['Content-Length'] = this._body.length.toString();
          }
      };
      XMLHttpRequestUpload.prototype._startUpload = function (request) {
          if (this._body) {
              request.write(this._body);
          }
          request.end();
      };
      return XMLHttpRequestUpload;
  }(xml_http_request_event_target_1.XMLHttpRequestEventTarget));
  exports.XMLHttpRequestUpload = XMLHttpRequestUpload;
  
  }).call(this,require("buffer").Buffer)
  
  },{"./xml-http-request-event-target":130,"buffer":55}],132:[function(require,module,exports){
  (function (process,Buffer){
  "use strict";
  var __extends = (this && this.__extends) || (function () {
      var extendStatics = Object.setPrototypeOf ||
          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
          function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
      return function (d, b) {
          extendStatics(d, b);
          function __() { this.constructor = d; }
          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
      };
  })();
  var __assign = (this && this.__assign) || Object.assign || function(t) {
      for (var s, i = 1, n = arguments.length; i < n; i++) {
          s = arguments[i];
          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
              t[p] = s[p];
      }
      return t;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  var http = require("http");
  var https = require("https");
  var os = require("os");
  var url = require("url");
  var progress_event_1 = require("./progress-event");
  var errors_1 = require("./errors");
  var xml_http_request_event_target_1 = require("./xml-http-request-event-target");
  var xml_http_request_upload_1 = require("./xml-http-request-upload");
  var Cookie = require("cookiejar");
  var XMLHttpRequest = /** @class */ (function (_super) {
      __extends(XMLHttpRequest, _super);
      function XMLHttpRequest(options) {
          if (options === void 0) { options = {}; }
          var _this = _super.call(this) || this;
          _this.UNSENT = XMLHttpRequest.UNSENT;
          _this.OPENED = XMLHttpRequest.OPENED;
          _this.HEADERS_RECEIVED = XMLHttpRequest.HEADERS_RECEIVED;
          _this.LOADING = XMLHttpRequest.LOADING;
          _this.DONE = XMLHttpRequest.DONE;
          _this.onreadystatechange = null;
          _this.readyState = XMLHttpRequest.UNSENT;
          _this.response = null;
          _this.responseText = '';
          _this.responseType = '';
          _this.status = 0; // TODO: UNSENT?
          _this.statusText = '';
          _this.timeout = 0;
          _this.upload = new xml_http_request_upload_1.XMLHttpRequestUpload();
          _this.responseUrl = '';
          _this.withCredentials = false;
          _this._method = null;
          _this._url = null;
          _this._sync = false;
          _this._headers = {};
          _this._loweredHeaders = {};
          _this._mimeOverride = null; // TODO: is type right?
          _this._request = null;
          _this._response = null;
          _this._responseParts = null;
          _this._responseHeaders = null;
          _this._aborting = null; // TODO: type?
          _this._error = null; // TODO: type?
          _this._loadedBytes = 0;
          _this._totalBytes = 0;
          _this._lengthComputable = false;
          _this._restrictedMethods = { CONNECT: true, TRACE: true, TRACK: true };
          _this._restrictedHeaders = {
              'accept-charset': true,
              'accept-encoding': true,
              'access-control-request-headers': true,
              'access-control-request-method': true,
              connection: true,
              'content-length': true,
              cookie: true,
              cookie2: true,
              date: true,
              dnt: true,
              expect: true,
              host: true,
              'keep-alive': true,
              origin: true,
              referer: true,
              te: true,
              trailer: true,
              'transfer-encoding': true,
              upgrade: true,
              'user-agent': true,
              via: true
          };
          _this._privateHeaders = { 'set-cookie': true, 'set-cookie2': true };
          _this._userAgent = "Mozilla/5.0 (" + os.type() + " " + os.arch() + ") node.js/" + process.versions.node + " v8/" + process.versions.v8;
          _this._anonymous = options.anon || false;
          return _this;
      }
      XMLHttpRequest.prototype.open = function (method, url, async, user, password) {
          if (async === void 0) { async = true; }
          method = method.toUpperCase();
          if (this._restrictedMethods[method]) {
              throw new XMLHttpRequest.SecurityError("HTTP method " + method + " is not allowed in XHR");
          }
          ;
          var xhrUrl = this._parseUrl(url, user, password);
          if (this.readyState === XMLHttpRequest.HEADERS_RECEIVED || this.readyState === XMLHttpRequest.LOADING) {
              // TODO(pwnall): terminate abort(), terminate send()
          }
          this._method = method;
          this._url = xhrUrl;
          this._sync = !async;
          this._headers = {};
          this._loweredHeaders = {};
          this._mimeOverride = null;
          this._setReadyState(XMLHttpRequest.OPENED);
          this._request = null;
          this._response = null;
          this.status = 0;
          this.statusText = '';
          this._responseParts = [];
          this._responseHeaders = null;
          this._loadedBytes = 0;
          this._totalBytes = 0;
          this._lengthComputable = false;
      };
      XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
          if (this.readyState !== XMLHttpRequest.OPENED) {
              throw new XMLHttpRequest.InvalidStateError('XHR readyState must be OPENED');
          }
          var loweredName = name.toLowerCase();
          if (this._restrictedHeaders[loweredName] || /^sec-/.test(loweredName) || /^proxy-/.test(loweredName)) {
              console.warn("Refused to set unsafe header \"" + name + "\"");
              return;
          }
          value = value.toString();
          if (this._loweredHeaders[loweredName] != null) {
              name = this._loweredHeaders[loweredName];
              this._headers[name] = this._headers[name] + ", " + value;
          }
          else {
              this._loweredHeaders[loweredName] = name;
              this._headers[name] = value;
          }
      };
      XMLHttpRequest.prototype.send = function (data) {
          if (this.readyState !== XMLHttpRequest.OPENED) {
              throw new XMLHttpRequest.InvalidStateError('XHR readyState must be OPENED');
          }
          if (this._request) {
              throw new XMLHttpRequest.InvalidStateError('send() already called');
          }
          switch (this._url.protocol) {
              case 'file:':
                  return this._sendFile(data);
              case 'http:':
              case 'https:':
                  return this._sendHttp(data);
              default:
                  throw new XMLHttpRequest.NetworkError("Unsupported protocol " + this._url.protocol);
          }
      };
      XMLHttpRequest.prototype.abort = function () {
          if (this._request == null) {
              return;
          }
          this._request.abort();
          this._setError();
          this._dispatchProgress('abort');
          this._dispatchProgress('loadend');
      };
      XMLHttpRequest.prototype.getResponseHeader = function (name) {
          if (this._responseHeaders == null || name == null) {
              return null;
          }
          var loweredName = name.toLowerCase();
          return this._responseHeaders.hasOwnProperty(loweredName)
              ? this._responseHeaders[name.toLowerCase()]
              : null;
      };
      XMLHttpRequest.prototype.getAllResponseHeaders = function () {
          var _this = this;
          if (this._responseHeaders == null) {
              return '';
          }
          return Object.keys(this._responseHeaders).map(function (key) { return key + ": " + _this._responseHeaders[key]; }).join('\r\n');
      };
      XMLHttpRequest.prototype.overrideMimeType = function (mimeType) {
          if (this.readyState === XMLHttpRequest.LOADING || this.readyState === XMLHttpRequest.DONE) {
              throw new XMLHttpRequest.InvalidStateError('overrideMimeType() not allowed in LOADING or DONE');
          }
          this._mimeOverride = mimeType.toLowerCase();
      };
      XMLHttpRequest.prototype.nodejsSet = function (options) {
          this.nodejsHttpAgent = options.httpAgent || this.nodejsHttpAgent;
          this.nodejsHttpsAgent = options.httpsAgent || this.nodejsHttpsAgent;
          if (options.hasOwnProperty('baseUrl')) {
              if (options.baseUrl != null) {
                  var parsedUrl = url.parse(options.baseUrl, false, true);
                  if (!parsedUrl.protocol) {
                      throw new XMLHttpRequest.SyntaxError("baseUrl must be an absolute URL");
                  }
              }
              this.nodejsBaseUrl = options.baseUrl;
          }
      };
      XMLHttpRequest.nodejsSet = function (options) {
          XMLHttpRequest.prototype.nodejsSet(options);
      };
      XMLHttpRequest.prototype._setReadyState = function (readyState) {
          this.readyState = readyState;
          this.dispatchEvent(new progress_event_1.ProgressEvent('readystatechange'));
      };
      XMLHttpRequest.prototype._sendFile = function (data) {
          // TODO
          throw new Error('Protocol file: not implemented');
      };
      XMLHttpRequest.prototype._sendHttp = function (data) {
          if (this._sync) {
              throw new Error('Synchronous XHR processing not implemented');
          }
          if (data && (this._method === 'GET' || this._method === 'HEAD')) {
              console.warn("Discarding entity body for " + this._method + " requests");
              data = null;
          }
          else {
              data = data || '';
          }
          this.upload._setData(data);
          this._finalizeHeaders();
          this._sendHxxpRequest();
      };
      XMLHttpRequest.prototype._sendHxxpRequest = function () {
          var _this = this;
          if (this.withCredentials) {
              var cookie = XMLHttpRequest.cookieJar
                  .getCookies(Cookie.CookieAccessInfo(this._url.hostname, this._url.pathname, this._url.protocol === 'https:')).toValueString();
              this._headers.cookie = this._headers.cookie2 = cookie;
          }
          var _a = this._url.protocol === 'http:' ? [http, this.nodejsHttpAgent] : [https, this.nodejsHttpsAgent], hxxp = _a[0], agent = _a[1];
          var requestMethod = hxxp.request.bind(hxxp);
          var request = requestMethod({
              hostname: this._url.hostname,
              port: +this._url.port,
              path: this._url.path,
              auth: this._url.auth,
              method: this._method,
              headers: this._headers,
              agent: agent
          });
          this._request = request;
          if (this.timeout) {
              request.setTimeout(this.timeout, function () { return _this._onHttpTimeout(request); });
          }
          request.on('response', function (response) { return _this._onHttpResponse(request, response); });
          request.on('error', function (error) { return _this._onHttpRequestError(request, error); });
          this.upload._startUpload(request);
          if (this._request === request) {
              this._dispatchProgress('loadstart');
          }
      };
      XMLHttpRequest.prototype._finalizeHeaders = function () {
          this._headers = __assign({}, this._headers, { Connection: 'keep-alive', Host: this._url.host, 'User-Agent': this._userAgent }, this._anonymous ? { Referer: 'about:blank' } : {});
          this.upload._finalizeHeaders(this._headers, this._loweredHeaders);
      };
      XMLHttpRequest.prototype._onHttpResponse = function (request, response) {
          var _this = this;
          if (this._request !== request) {
              return;
          }
          if (this.withCredentials && (response.headers['set-cookie'] || response.headers['set-cookie2'])) {
              XMLHttpRequest.cookieJar
                  .setCookies(response.headers['set-cookie'] || response.headers['set-cookie2']);
          }
          if ([301, 302, 303, 307, 308].indexOf(response.statusCode) >= 0) {
              this._url = this._parseUrl(response.headers.location);
              this._method = 'GET';
              if (this._loweredHeaders['content-type']) {
                  delete this._headers[this._loweredHeaders['content-type']];
                  delete this._loweredHeaders['content-type'];
              }
              if (this._headers['Content-Type'] != null) {
                  delete this._headers['Content-Type'];
              }
              delete this._headers['Content-Length'];
              this.upload._reset();
              this._finalizeHeaders();
              this._sendHxxpRequest();
              return;
          }
          this._response = response;
          this._response.on('data', function (data) { return _this._onHttpResponseData(response, data); });
          this._response.on('end', function () { return _this._onHttpResponseEnd(response); });
          this._response.on('close', function () { return _this._onHttpResponseClose(response); });
          this.responseUrl = this._url.href.split('#')[0];
          this.status = response.statusCode;
          this.statusText = http.STATUS_CODES[this.status];
          this._parseResponseHeaders(response);
          var lengthString = this._responseHeaders['content-length'] || '';
          this._totalBytes = +lengthString;
          this._lengthComputable = !!lengthString;
          this._setReadyState(XMLHttpRequest.HEADERS_RECEIVED);
      };
      XMLHttpRequest.prototype._onHttpResponseData = function (response, data) {
          if (this._response !== response) {
              return;
          }
          this._responseParts.push(new Buffer(data));
          this._loadedBytes += data.length;
          if (this.readyState !== XMLHttpRequest.LOADING) {
              this._setReadyState(XMLHttpRequest.LOADING);
          }
          this._dispatchProgress('progress');
      };
      XMLHttpRequest.prototype._onHttpResponseEnd = function (response) {
          if (this._response !== response) {
              return;
          }
          this._parseResponse();
          this._request = null;
          this._response = null;
          this._setReadyState(XMLHttpRequest.DONE);
          this._dispatchProgress('load');
          this._dispatchProgress('loadend');
      };
      XMLHttpRequest.prototype._onHttpResponseClose = function (response) {
          if (this._response !== response) {
              return;
          }
          var request = this._request;
          this._setError();
          request.abort();
          this._setReadyState(XMLHttpRequest.DONE);
          this._dispatchProgress('error');
          this._dispatchProgress('loadend');
      };
      XMLHttpRequest.prototype._onHttpTimeout = function (request) {
          if (this._request !== request) {
              return;
          }
          this._setError();
          request.abort();
          this._setReadyState(XMLHttpRequest.DONE);
          this._dispatchProgress('timeout');
          this._dispatchProgress('loadend');
      };
      XMLHttpRequest.prototype._onHttpRequestError = function (request, error) {
          if (this._request !== request) {
              return;
          }
          this._setError();
          request.abort();
          this._setReadyState(XMLHttpRequest.DONE);
          this._dispatchProgress('error');
          this._dispatchProgress('loadend');
      };
      XMLHttpRequest.prototype._dispatchProgress = function (eventType) {
          var event = new XMLHttpRequest.ProgressEvent(eventType);
          event.lengthComputable = this._lengthComputable;
          event.loaded = this._loadedBytes;
          event.total = this._totalBytes;
          this.dispatchEvent(event);
      };
      XMLHttpRequest.prototype._setError = function () {
          this._request = null;
          this._response = null;
          this._responseHeaders = null;
          this._responseParts = null;
      };
      XMLHttpRequest.prototype._parseUrl = function (urlString, user, password) {
          var absoluteUrl = this.nodejsBaseUrl == null ? urlString : url.resolve(this.nodejsBaseUrl, urlString);
          var xhrUrl = url.parse(absoluteUrl, false, true);
          xhrUrl.hash = null;
          var _a = (xhrUrl.auth || '').split(':'), xhrUser = _a[0], xhrPassword = _a[1];
          if (xhrUser || xhrPassword || user || password) {
              xhrUrl.auth = (user || xhrUser || '') + ":" + (password || xhrPassword || '');
          }
          return xhrUrl;
      };
      XMLHttpRequest.prototype._parseResponseHeaders = function (response) {
          this._responseHeaders = {};
          for (var name_1 in response.headers) {
              var loweredName = name_1.toLowerCase();
              if (this._privateHeaders[loweredName]) {
                  continue;
              }
              this._responseHeaders[loweredName] = response.headers[name_1];
          }
          if (this._mimeOverride != null) {
              this._responseHeaders['content-type'] = this._mimeOverride;
          }
      };
      XMLHttpRequest.prototype._parseResponse = function () {
          var buffer = Buffer.concat(this._responseParts);
          this._responseParts = null;
          switch (this.responseType) {
              case 'json':
                  this.responseText = null;
                  try {
                      this.response = JSON.parse(buffer.toString('utf-8'));
                  }
                  catch (_a) {
                      this.response = null;
                  }
                  return;
              case 'buffer':
                  this.responseText = null;
                  this.response = buffer;
                  return;
              case 'arraybuffer':
                  this.responseText = null;
                  var arrayBuffer = new ArrayBuffer(buffer.length);
                  var view = new Uint8Array(arrayBuffer);
                  for (var i = 0; i < buffer.length; i++) {
                      view[i] = buffer[i];
                  }
                  this.response = arrayBuffer;
                  return;
              case 'text':
              default:
                  try {
                      this.responseText = buffer.toString(this._parseResponseEncoding());
                  }
                  catch (_b) {
                      this.responseText = buffer.toString('binary');
                  }
                  this.response = this.responseText;
          }
      };
      XMLHttpRequest.prototype._parseResponseEncoding = function () {
          return /;\s*charset=(.*)$/.exec(this._responseHeaders['content-type'] || '')[1] || 'utf-8';
      };
      XMLHttpRequest.ProgressEvent = progress_event_1.ProgressEvent;
      XMLHttpRequest.InvalidStateError = errors_1.InvalidStateError;
      XMLHttpRequest.NetworkError = errors_1.NetworkError;
      XMLHttpRequest.SecurityError = errors_1.SecurityError;
      XMLHttpRequest.SyntaxError = errors_1.SyntaxError;
      XMLHttpRequest.XMLHttpRequestUpload = xml_http_request_upload_1.XMLHttpRequestUpload;
      XMLHttpRequest.UNSENT = 0;
      XMLHttpRequest.OPENED = 1;
      XMLHttpRequest.HEADERS_RECEIVED = 2;
      XMLHttpRequest.LOADING = 3;
      XMLHttpRequest.DONE = 4;
      XMLHttpRequest.cookieJar = Cookie.CookieJar();
      return XMLHttpRequest;
  }(xml_http_request_event_target_1.XMLHttpRequestEventTarget));
  exports.XMLHttpRequest = XMLHttpRequest;
  XMLHttpRequest.prototype.nodejsHttpAgent = http.globalAgent;
  XMLHttpRequest.prototype.nodejsHttpsAgent = https.globalAgent;
  XMLHttpRequest.prototype.nodejsBaseUrl = null;
  
  }).call(this,require('_process'),require("buffer").Buffer)
  
  },{"./errors":127,"./progress-event":129,"./xml-http-request-event-target":130,"./xml-http-request-upload":131,"_process":101,"buffer":55,"cookiejar":57,"http":117,"https":94,"os":99,"url":123}],133:[function(require,module,exports){
  module.exports = extend
  
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  
  function extend() {
      var target = {}
  
      for (var i = 0; i < arguments.length; i++) {
          var source = arguments[i]
  
          for (var key in source) {
              if (hasOwnProperty.call(source, key)) {
                  target[key] = source[key]
              }
          }
      }
  
      return target
  }
  
  },{}],"bignumber.js":[function(require,module,exports){
  'use strict';
  
  module.exports = BigNumber; // jshint ignore:line
  
  
  },{}],"web4bch":[function(require,module,exports){
  var Web4Bch = require('./lib/web4bch');
  
  // dont override global variable
  if (typeof window !== 'undefined' && typeof window.Web4Bch === 'undefined') {
      window.Web4Bch = Web4Bch;
  }
  
  module.exports = Web4Bch;
  
  },{"./lib/web4bch":22}]},{},["web4bch"])
  //# sourceMappingURL=web4bch-light.js.map
  