(window["webpackJsonpSNCrypto"] = window["webpackJsonpSNCrypto"] || []).push([["vendors~libsodium"],{

/***/ "./node_modules/asn1.js/lib/asn1.js":
/*!******************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var asn1 = exports;
asn1.bignum = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");
asn1.define = __webpack_require__(/*! ./asn1/api */ "./node_modules/asn1.js/lib/asn1/api.js").define;
asn1.base = __webpack_require__(/*! ./asn1/base */ "./node_modules/asn1.js/lib/asn1/base/index.js");
asn1.constants = __webpack_require__(/*! ./asn1/constants */ "./node_modules/asn1.js/lib/asn1/constants/index.js");
asn1.decoders = __webpack_require__(/*! ./asn1/decoders */ "./node_modules/asn1.js/lib/asn1/decoders/index.js");
asn1.encoders = __webpack_require__(/*! ./asn1/encoders */ "./node_modules/asn1.js/lib/asn1/encoders/index.js");

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/api.js":
/*!**********************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/api.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var asn1 = __webpack_require__(/*! ../asn1 */ "./node_modules/asn1.js/lib/asn1.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var api = exports;

api.define = function define(name, body) {
  return new Entity(name, body);
};

function Entity(name, body) {
  this.name = name;
  this.body = body;
  this.decoders = {};
  this.encoders = {};
}

;

Entity.prototype._createNamed = function createNamed(base) {
  var named;

  try {
    named = __webpack_require__(/*! vm */ "./node_modules/vm-browserify/index.js").runInThisContext('(function ' + this.name + '(entity) {\n' + '  this._initNamed(entity);\n' + '})');
  } catch (e) {
    named = function named(entity) {
      this._initNamed(entity);
    };
  }

  inherits(named, base);

  named.prototype._initNamed = function initnamed(entity) {
    base.call(this, entity);
  };

  return new named(this);
};

Entity.prototype._getDecoder = function _getDecoder(enc) {
  enc = enc || 'der'; // Lazily create decoder

  if (!this.decoders.hasOwnProperty(enc)) this.decoders[enc] = this._createNamed(asn1.decoders[enc]);
  return this.decoders[enc];
};

Entity.prototype.decode = function decode(data, enc, options) {
  return this._getDecoder(enc).decode(data, options);
};

Entity.prototype._getEncoder = function _getEncoder(enc) {
  enc = enc || 'der'; // Lazily create encoder

  if (!this.encoders.hasOwnProperty(enc)) this.encoders[enc] = this._createNamed(asn1.encoders[enc]);
  return this.encoders[enc];
};

Entity.prototype.encode = function encode(data, enc,
/* internal */
reporter) {
  return this._getEncoder(enc).encode(data, reporter);
};

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/base/buffer.js":
/*!******************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/base/buffer.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Reporter = __webpack_require__(/*! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js").Reporter;

var Buffer = __webpack_require__(/*! buffer */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer;

function DecoderBuffer(base, options) {
  Reporter.call(this, options);

  if (!Buffer.isBuffer(base)) {
    this.error('Input not Buffer');
    return;
  }

  this.base = base;
  this.offset = 0;
  this.length = base.length;
}

inherits(DecoderBuffer, Reporter);
exports.DecoderBuffer = DecoderBuffer;

DecoderBuffer.prototype.save = function save() {
  return {
    offset: this.offset,
    reporter: Reporter.prototype.save.call(this)
  };
};

DecoderBuffer.prototype.restore = function restore(save) {
  // Return skipped data
  var res = new DecoderBuffer(this.base);
  res.offset = save.offset;
  res.length = this.offset;
  this.offset = save.offset;
  Reporter.prototype.restore.call(this, save.reporter);
  return res;
};

DecoderBuffer.prototype.isEmpty = function isEmpty() {
  return this.offset === this.length;
};

DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
  if (this.offset + 1 <= this.length) return this.base.readUInt8(this.offset++, true);else return this.error(fail || 'DecoderBuffer overrun');
};

DecoderBuffer.prototype.skip = function skip(bytes, fail) {
  if (!(this.offset + bytes <= this.length)) return this.error(fail || 'DecoderBuffer overrun');
  var res = new DecoderBuffer(this.base); // Share reporter state

  res._reporterState = this._reporterState;
  res.offset = this.offset;
  res.length = this.offset + bytes;
  this.offset += bytes;
  return res;
};

DecoderBuffer.prototype.raw = function raw(save) {
  return this.base.slice(save ? save.offset : this.offset, this.length);
};

function EncoderBuffer(value, reporter) {
  if (Array.isArray(value)) {
    this.length = 0;
    this.value = value.map(function (item) {
      if (!(item instanceof EncoderBuffer)) item = new EncoderBuffer(item, reporter);
      this.length += item.length;
      return item;
    }, this);
  } else if (typeof value === 'number') {
    if (!(0 <= value && value <= 0xff)) return reporter.error('non-byte EncoderBuffer value');
    this.value = value;
    this.length = 1;
  } else if (typeof value === 'string') {
    this.value = value;
    this.length = Buffer.byteLength(value);
  } else if (Buffer.isBuffer(value)) {
    this.value = value;
    this.length = value.length;
  } else {
    return reporter.error('Unsupported type: ' + _typeof(value));
  }
}

exports.EncoderBuffer = EncoderBuffer;

EncoderBuffer.prototype.join = function join(out, offset) {
  if (!out) out = new Buffer(this.length);
  if (!offset) offset = 0;
  if (this.length === 0) return out;

  if (Array.isArray(this.value)) {
    this.value.forEach(function (item) {
      item.join(out, offset);
      offset += item.length;
    });
  } else {
    if (typeof this.value === 'number') out[offset] = this.value;else if (typeof this.value === 'string') out.write(this.value, offset);else if (Buffer.isBuffer(this.value)) this.value.copy(out, offset);
    offset += this.length;
  }

  return out;
};

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/base/index.js":
/*!*****************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/base/index.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var base = exports;
base.Reporter = __webpack_require__(/*! ./reporter */ "./node_modules/asn1.js/lib/asn1/base/reporter.js").Reporter;
base.DecoderBuffer = __webpack_require__(/*! ./buffer */ "./node_modules/asn1.js/lib/asn1/base/buffer.js").DecoderBuffer;
base.EncoderBuffer = __webpack_require__(/*! ./buffer */ "./node_modules/asn1.js/lib/asn1/base/buffer.js").EncoderBuffer;
base.Node = __webpack_require__(/*! ./node */ "./node_modules/asn1.js/lib/asn1/base/node.js");

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/base/node.js":
/*!****************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/base/node.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var Reporter = __webpack_require__(/*! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js").Reporter;

var EncoderBuffer = __webpack_require__(/*! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js").EncoderBuffer;

var DecoderBuffer = __webpack_require__(/*! ../base */ "./node_modules/asn1.js/lib/asn1/base/index.js").DecoderBuffer;

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js"); // Supported tags


var tags = ['seq', 'seqof', 'set', 'setof', 'objid', 'bool', 'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc', 'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str', 'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr']; // Public methods list

var methods = ['key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice', 'any', 'contains'].concat(tags); // Overrided methods list

var overrided = ['_peekTag', '_decodeTag', '_use', '_decodeStr', '_decodeObjid', '_decodeTime', '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList', '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime', '_encodeNull', '_encodeInt', '_encodeBool'];

function Node(enc, parent) {
  var state = {};
  this._baseState = state;
  state.enc = enc;
  state.parent = parent || null;
  state.children = null; // State

  state.tag = null;
  state.args = null;
  state.reverseArgs = null;
  state.choice = null;
  state.optional = false;
  state.any = false;
  state.obj = false;
  state.use = null;
  state.useDecoder = null;
  state.key = null;
  state['default'] = null;
  state.explicit = null;
  state.implicit = null;
  state.contains = null; // Should create new instance on each method

  if (!state.parent) {
    state.children = [];

    this._wrap();
  }
}

module.exports = Node;
var stateProps = ['enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice', 'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit', 'implicit', 'contains'];

Node.prototype.clone = function clone() {
  var state = this._baseState;
  var cstate = {};
  stateProps.forEach(function (prop) {
    cstate[prop] = state[prop];
  });
  var res = new this.constructor(cstate.parent);
  res._baseState = cstate;
  return res;
};

Node.prototype._wrap = function wrap() {
  var state = this._baseState;
  methods.forEach(function (method) {
    this[method] = function _wrappedMethod() {
      var clone = new this.constructor(this);
      state.children.push(clone);
      return clone[method].apply(clone, arguments);
    };
  }, this);
};

Node.prototype._init = function init(body) {
  var state = this._baseState;
  assert(state.parent === null);
  body.call(this); // Filter children

  state.children = state.children.filter(function (child) {
    return child._baseState.parent === this;
  }, this);
  assert.equal(state.children.length, 1, 'Root node can have only one child');
};

Node.prototype._useArgs = function useArgs(args) {
  var state = this._baseState; // Filter children and args

  var children = args.filter(function (arg) {
    return arg instanceof this.constructor;
  }, this);
  args = args.filter(function (arg) {
    return !(arg instanceof this.constructor);
  }, this);

  if (children.length !== 0) {
    assert(state.children === null);
    state.children = children; // Replace parent to maintain backward link

    children.forEach(function (child) {
      child._baseState.parent = this;
    }, this);
  }

  if (args.length !== 0) {
    assert(state.args === null);
    state.args = args;
    state.reverseArgs = args.map(function (arg) {
      if (_typeof(arg) !== 'object' || arg.constructor !== Object) return arg;
      var res = {};
      Object.keys(arg).forEach(function (key) {
        if (key == (key | 0)) key |= 0;
        var value = arg[key];
        res[value] = key;
      });
      return res;
    });
  }
}; //
// Overrided methods
//


overrided.forEach(function (method) {
  Node.prototype[method] = function _overrided() {
    var state = this._baseState;
    throw new Error(method + ' not implemented for encoding: ' + state.enc);
  };
}); //
// Public methods
//

tags.forEach(function (tag) {
  Node.prototype[tag] = function _tagMethod() {
    var state = this._baseState;
    var args = Array.prototype.slice.call(arguments);
    assert(state.tag === null);
    state.tag = tag;

    this._useArgs(args);

    return this;
  };
});

Node.prototype.use = function use(item) {
  assert(item);
  var state = this._baseState;
  assert(state.use === null);
  state.use = item;
  return this;
};

Node.prototype.optional = function optional() {
  var state = this._baseState;
  state.optional = true;
  return this;
};

Node.prototype.def = function def(val) {
  var state = this._baseState;
  assert(state['default'] === null);
  state['default'] = val;
  state.optional = true;
  return this;
};

Node.prototype.explicit = function explicit(num) {
  var state = this._baseState;
  assert(state.explicit === null && state.implicit === null);
  state.explicit = num;
  return this;
};

Node.prototype.implicit = function implicit(num) {
  var state = this._baseState;
  assert(state.explicit === null && state.implicit === null);
  state.implicit = num;
  return this;
};

Node.prototype.obj = function obj() {
  var state = this._baseState;
  var args = Array.prototype.slice.call(arguments);
  state.obj = true;
  if (args.length !== 0) this._useArgs(args);
  return this;
};

Node.prototype.key = function key(newKey) {
  var state = this._baseState;
  assert(state.key === null);
  state.key = newKey;
  return this;
};

Node.prototype.any = function any() {
  var state = this._baseState;
  state.any = true;
  return this;
};

Node.prototype.choice = function choice(obj) {
  var state = this._baseState;
  assert(state.choice === null);
  state.choice = obj;

  this._useArgs(Object.keys(obj).map(function (key) {
    return obj[key];
  }));

  return this;
};

Node.prototype.contains = function contains(item) {
  var state = this._baseState;
  assert(state.use === null);
  state.contains = item;
  return this;
}; //
// Decoding
//


Node.prototype._decode = function decode(input, options) {
  var state = this._baseState; // Decode root node

  if (state.parent === null) return input.wrapResult(state.children[0]._decode(input, options));
  var result = state['default'];
  var present = true;
  var prevKey = null;
  if (state.key !== null) prevKey = input.enterKey(state.key); // Check if tag is there

  if (state.optional) {
    var tag = null;
    if (state.explicit !== null) tag = state.explicit;else if (state.implicit !== null) tag = state.implicit;else if (state.tag !== null) tag = state.tag;

    if (tag === null && !state.any) {
      // Trial and Error
      var save = input.save();

      try {
        if (state.choice === null) this._decodeGeneric(state.tag, input, options);else this._decodeChoice(input, options);
        present = true;
      } catch (e) {
        present = false;
      }

      input.restore(save);
    } else {
      present = this._peekTag(input, tag, state.any);
      if (input.isError(present)) return present;
    }
  } // Push object on stack


  var prevObj;
  if (state.obj && present) prevObj = input.enterObject();

  if (present) {
    // Unwrap explicit values
    if (state.explicit !== null) {
      var explicit = this._decodeTag(input, state.explicit);

      if (input.isError(explicit)) return explicit;
      input = explicit;
    }

    var start = input.offset; // Unwrap implicit and normal values

    if (state.use === null && state.choice === null) {
      if (state.any) var save = input.save();

      var body = this._decodeTag(input, state.implicit !== null ? state.implicit : state.tag, state.any);

      if (input.isError(body)) return body;
      if (state.any) result = input.raw(save);else input = body;
    }

    if (options && options.track && state.tag !== null) options.track(input.path(), start, input.length, 'tagged');
    if (options && options.track && state.tag !== null) options.track(input.path(), input.offset, input.length, 'content'); // Select proper method for tag

    if (state.any) result = result;else if (state.choice === null) result = this._decodeGeneric(state.tag, input, options);else result = this._decodeChoice(input, options);
    if (input.isError(result)) return result; // Decode children

    if (!state.any && state.choice === null && state.children !== null) {
      state.children.forEach(function decodeChildren(child) {
        // NOTE: We are ignoring errors here, to let parser continue with other
        // parts of encoded data
        child._decode(input, options);
      });
    } // Decode contained/encoded by schema, only in bit or octet strings


    if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {
      var data = new DecoderBuffer(result);
      result = this._getUse(state.contains, input._reporterState.obj)._decode(data, options);
    }
  } // Pop object


  if (state.obj && present) result = input.leaveObject(prevObj); // Set key

  if (state.key !== null && (result !== null || present === true)) input.leaveKey(prevKey, state.key, result);else if (prevKey !== null) input.exitKey(prevKey);
  return result;
};

Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
  var state = this._baseState;
  if (tag === 'seq' || tag === 'set') return null;
  if (tag === 'seqof' || tag === 'setof') return this._decodeList(input, tag, state.args[0], options);else if (/str$/.test(tag)) return this._decodeStr(input, tag, options);else if (tag === 'objid' && state.args) return this._decodeObjid(input, state.args[0], state.args[1], options);else if (tag === 'objid') return this._decodeObjid(input, null, null, options);else if (tag === 'gentime' || tag === 'utctime') return this._decodeTime(input, tag, options);else if (tag === 'null_') return this._decodeNull(input, options);else if (tag === 'bool') return this._decodeBool(input, options);else if (tag === 'objDesc') return this._decodeStr(input, tag, options);else if (tag === 'int' || tag === 'enum') return this._decodeInt(input, state.args && state.args[0], options);

  if (state.use !== null) {
    return this._getUse(state.use, input._reporterState.obj)._decode(input, options);
  } else {
    return input.error('unknown tag: ' + tag);
  }
};

Node.prototype._getUse = function _getUse(entity, obj) {
  var state = this._baseState; // Create altered use decoder if implicit is set

  state.useDecoder = this._use(entity, obj);
  assert(state.useDecoder._baseState.parent === null);
  state.useDecoder = state.useDecoder._baseState.children[0];

  if (state.implicit !== state.useDecoder._baseState.implicit) {
    state.useDecoder = state.useDecoder.clone();
    state.useDecoder._baseState.implicit = state.implicit;
  }

  return state.useDecoder;
};

Node.prototype._decodeChoice = function decodeChoice(input, options) {
  var state = this._baseState;
  var result = null;
  var match = false;
  Object.keys(state.choice).some(function (key) {
    var save = input.save();
    var node = state.choice[key];

    try {
      var value = node._decode(input, options);

      if (input.isError(value)) return false;
      result = {
        type: key,
        value: value
      };
      match = true;
    } catch (e) {
      input.restore(save);
      return false;
    }

    return true;
  }, this);
  if (!match) return input.error('Choice not matched');
  return result;
}; //
// Encoding
//


Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
  return new EncoderBuffer(data, this.reporter);
};

Node.prototype._encode = function encode(data, reporter, parent) {
  var state = this._baseState;
  if (state['default'] !== null && state['default'] === data) return;

  var result = this._encodeValue(data, reporter, parent);

  if (result === undefined) return;
  if (this._skipDefault(result, reporter, parent)) return;
  return result;
};

Node.prototype._encodeValue = function encode(data, reporter, parent) {
  var state = this._baseState; // Decode root node

  if (state.parent === null) return state.children[0]._encode(data, reporter || new Reporter());
  var result = null; // Set reporter to share it with a child class

  this.reporter = reporter; // Check if data is there

  if (state.optional && data === undefined) {
    if (state['default'] !== null) data = state['default'];else return;
  } // Encode children first


  var content = null;
  var primitive = false;

  if (state.any) {
    // Anything that was given is translated to buffer
    result = this._createEncoderBuffer(data);
  } else if (state.choice) {
    result = this._encodeChoice(data, reporter);
  } else if (state.contains) {
    content = this._getUse(state.contains, parent)._encode(data, reporter);
    primitive = true;
  } else if (state.children) {
    content = state.children.map(function (child) {
      if (child._baseState.tag === 'null_') return child._encode(null, reporter, data);
      if (child._baseState.key === null) return reporter.error('Child should have a key');
      var prevKey = reporter.enterKey(child._baseState.key);
      if (_typeof(data) !== 'object') return reporter.error('Child expected, but input is not object');

      var res = child._encode(data[child._baseState.key], reporter, data);

      reporter.leaveKey(prevKey);
      return res;
    }, this).filter(function (child) {
      return child;
    });
    content = this._createEncoderBuffer(content);
  } else {
    if (state.tag === 'seqof' || state.tag === 'setof') {
      // TODO(indutny): this should be thrown on DSL level
      if (!(state.args && state.args.length === 1)) return reporter.error('Too many args for : ' + state.tag);
      if (!Array.isArray(data)) return reporter.error('seqof/setof, but data is not Array');
      var child = this.clone();
      child._baseState.implicit = null;
      content = this._createEncoderBuffer(data.map(function (item) {
        var state = this._baseState;
        return this._getUse(state.args[0], data)._encode(item, reporter);
      }, child));
    } else if (state.use !== null) {
      result = this._getUse(state.use, parent)._encode(data, reporter);
    } else {
      content = this._encodePrimitive(state.tag, data);
      primitive = true;
    }
  } // Encode data itself


  var result;

  if (!state.any && state.choice === null) {
    var tag = state.implicit !== null ? state.implicit : state.tag;
    var cls = state.implicit === null ? 'universal' : 'context';

    if (tag === null) {
      if (state.use === null) reporter.error('Tag could be omitted only for .use()');
    } else {
      if (state.use === null) result = this._encodeComposite(tag, primitive, cls, content);
    }
  } // Wrap in explicit


  if (state.explicit !== null) result = this._encodeComposite(state.explicit, false, 'context', result);
  return result;
};

Node.prototype._encodeChoice = function encodeChoice(data, reporter) {
  var state = this._baseState;
  var node = state.choice[data.type];

  if (!node) {
    assert(false, data.type + ' not found in ' + JSON.stringify(Object.keys(state.choice)));
  }

  return node._encode(data.value, reporter);
};

Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
  var state = this._baseState;
  if (/str$/.test(tag)) return this._encodeStr(data, tag);else if (tag === 'objid' && state.args) return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);else if (tag === 'objid') return this._encodeObjid(data, null, null);else if (tag === 'gentime' || tag === 'utctime') return this._encodeTime(data, tag);else if (tag === 'null_') return this._encodeNull();else if (tag === 'int' || tag === 'enum') return this._encodeInt(data, state.args && state.reverseArgs[0]);else if (tag === 'bool') return this._encodeBool(data);else if (tag === 'objDesc') return this._encodeStr(data, tag);else throw new Error('Unsupported tag: ' + tag);
};

Node.prototype._isNumstr = function isNumstr(str) {
  return /^[0-9 ]*$/.test(str);
};

Node.prototype._isPrintstr = function isPrintstr(str) {
  return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str);
};

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/base/reporter.js":
/*!********************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/base/reporter.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function Reporter(options) {
  this._reporterState = {
    obj: null,
    path: [],
    options: options || {},
    errors: []
  };
}

exports.Reporter = Reporter;

Reporter.prototype.isError = function isError(obj) {
  return obj instanceof ReporterError;
};

Reporter.prototype.save = function save() {
  var state = this._reporterState;
  return {
    obj: state.obj,
    pathLen: state.path.length
  };
};

Reporter.prototype.restore = function restore(data) {
  var state = this._reporterState;
  state.obj = data.obj;
  state.path = state.path.slice(0, data.pathLen);
};

Reporter.prototype.enterKey = function enterKey(key) {
  return this._reporterState.path.push(key);
};

Reporter.prototype.exitKey = function exitKey(index) {
  var state = this._reporterState;
  state.path = state.path.slice(0, index - 1);
};

Reporter.prototype.leaveKey = function leaveKey(index, key, value) {
  var state = this._reporterState;
  this.exitKey(index);
  if (state.obj !== null) state.obj[key] = value;
};

Reporter.prototype.path = function path() {
  return this._reporterState.path.join('/');
};

Reporter.prototype.enterObject = function enterObject() {
  var state = this._reporterState;
  var prev = state.obj;
  state.obj = {};
  return prev;
};

Reporter.prototype.leaveObject = function leaveObject(prev) {
  var state = this._reporterState;
  var now = state.obj;
  state.obj = prev;
  return now;
};

Reporter.prototype.error = function error(msg) {
  var err;
  var state = this._reporterState;
  var inherited = msg instanceof ReporterError;

  if (inherited) {
    err = msg;
  } else {
    err = new ReporterError(state.path.map(function (elem) {
      return '[' + JSON.stringify(elem) + ']';
    }).join(''), msg.message || msg, msg.stack);
  }

  if (!state.options.partial) throw err;
  if (!inherited) state.errors.push(err);
  return err;
};

Reporter.prototype.wrapResult = function wrapResult(result) {
  var state = this._reporterState;
  if (!state.options.partial) return result;
  return {
    result: this.isError(result) ? null : result,
    errors: state.errors
  };
};

function ReporterError(path, msg) {
  this.path = path;
  this.rethrow(msg);
}

;
inherits(ReporterError, Error);

ReporterError.prototype.rethrow = function rethrow(msg) {
  this.message = msg + ' at: ' + (this.path || '(shallow)');
  if (Error.captureStackTrace) Error.captureStackTrace(this, ReporterError);

  if (!this.stack) {
    try {
      // IE only adds stack when thrown
      throw new Error(this.message);
    } catch (e) {
      this.stack = e.stack;
    }
  }

  return this;
};

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/constants/der.js":
/*!********************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/constants/der.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var constants = __webpack_require__(/*! ../constants */ "./node_modules/asn1.js/lib/asn1/constants/index.js");

exports.tagClass = {
  0: 'universal',
  1: 'application',
  2: 'context',
  3: 'private'
};
exports.tagClassByName = constants._reverse(exports.tagClass);
exports.tag = {
  0x00: 'end',
  0x01: 'bool',
  0x02: 'int',
  0x03: 'bitstr',
  0x04: 'octstr',
  0x05: 'null_',
  0x06: 'objid',
  0x07: 'objDesc',
  0x08: 'external',
  0x09: 'real',
  0x0a: 'enum',
  0x0b: 'embed',
  0x0c: 'utf8str',
  0x0d: 'relativeOid',
  0x10: 'seq',
  0x11: 'set',
  0x12: 'numstr',
  0x13: 'printstr',
  0x14: 't61str',
  0x15: 'videostr',
  0x16: 'ia5str',
  0x17: 'utctime',
  0x18: 'gentime',
  0x19: 'graphstr',
  0x1a: 'iso646str',
  0x1b: 'genstr',
  0x1c: 'unistr',
  0x1d: 'charstr',
  0x1e: 'bmpstr'
};
exports.tagByName = constants._reverse(exports.tag);

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/constants/index.js":
/*!**********************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/constants/index.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var constants = exports; // Helper

constants._reverse = function reverse(map) {
  var res = {};
  Object.keys(map).forEach(function (key) {
    // Convert key to integer if it is stringified
    if ((key | 0) == key) key = key | 0;
    var value = map[key];
    res[value] = key;
  });
  return res;
};

constants.der = __webpack_require__(/*! ./der */ "./node_modules/asn1.js/lib/asn1/constants/der.js");

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/decoders/der.js":
/*!*******************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/decoders/der.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var asn1 = __webpack_require__(/*! ../../asn1 */ "./node_modules/asn1.js/lib/asn1.js");

var base = asn1.base;
var bignum = asn1.bignum; // Import DER constants

var der = asn1.constants.der;

function DERDecoder(entity) {
  this.enc = 'der';
  this.name = entity.name;
  this.entity = entity; // Construct base tree

  this.tree = new DERNode();

  this.tree._init(entity.body);
}

;
module.exports = DERDecoder;

DERDecoder.prototype.decode = function decode(data, options) {
  if (!(data instanceof base.DecoderBuffer)) data = new base.DecoderBuffer(data, options);
  return this.tree._decode(data, options);
}; // Tree methods


function DERNode(parent) {
  base.Node.call(this, 'der', parent);
}

inherits(DERNode, base.Node);

DERNode.prototype._peekTag = function peekTag(buffer, tag, any) {
  if (buffer.isEmpty()) return false;
  var state = buffer.save();
  var decodedTag = derDecodeTag(buffer, 'Failed to peek tag: "' + tag + '"');
  if (buffer.isError(decodedTag)) return decodedTag;
  buffer.restore(state);
  return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + 'of' === tag || any;
};

DERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {
  var decodedTag = derDecodeTag(buffer, 'Failed to decode tag of "' + tag + '"');
  if (buffer.isError(decodedTag)) return decodedTag;
  var len = derDecodeLen(buffer, decodedTag.primitive, 'Failed to get length of "' + tag + '"'); // Failure

  if (buffer.isError(len)) return len;

  if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + 'of' !== tag) {
    return buffer.error('Failed to match tag: "' + tag + '"');
  }

  if (decodedTag.primitive || len !== null) return buffer.skip(len, 'Failed to match body of: "' + tag + '"'); // Indefinite length... find END tag

  var state = buffer.save();

  var res = this._skipUntilEnd(buffer, 'Failed to skip indefinite length body: "' + this.tag + '"');

  if (buffer.isError(res)) return res;
  len = buffer.offset - state.offset;
  buffer.restore(state);
  return buffer.skip(len, 'Failed to match body of: "' + tag + '"');
};

DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {
  while (true) {
    var tag = derDecodeTag(buffer, fail);
    if (buffer.isError(tag)) return tag;
    var len = derDecodeLen(buffer, tag.primitive, fail);
    if (buffer.isError(len)) return len;
    var res;
    if (tag.primitive || len !== null) res = buffer.skip(len);else res = this._skipUntilEnd(buffer, fail); // Failure

    if (buffer.isError(res)) return res;
    if (tag.tagStr === 'end') break;
  }
};

DERNode.prototype._decodeList = function decodeList(buffer, tag, decoder, options) {
  var result = [];

  while (!buffer.isEmpty()) {
    var possibleEnd = this._peekTag(buffer, 'end');

    if (buffer.isError(possibleEnd)) return possibleEnd;
    var res = decoder.decode(buffer, 'der', options);
    if (buffer.isError(res) && possibleEnd) break;
    result.push(res);
  }

  return result;
};

DERNode.prototype._decodeStr = function decodeStr(buffer, tag) {
  if (tag === 'bitstr') {
    var unused = buffer.readUInt8();
    if (buffer.isError(unused)) return unused;
    return {
      unused: unused,
      data: buffer.raw()
    };
  } else if (tag === 'bmpstr') {
    var raw = buffer.raw();
    if (raw.length % 2 === 1) return buffer.error('Decoding of string type: bmpstr length mismatch');
    var str = '';

    for (var i = 0; i < raw.length / 2; i++) {
      str += String.fromCharCode(raw.readUInt16BE(i * 2));
    }

    return str;
  } else if (tag === 'numstr') {
    var numstr = buffer.raw().toString('ascii');

    if (!this._isNumstr(numstr)) {
      return buffer.error('Decoding of string type: ' + 'numstr unsupported characters');
    }

    return numstr;
  } else if (tag === 'octstr') {
    return buffer.raw();
  } else if (tag === 'objDesc') {
    return buffer.raw();
  } else if (tag === 'printstr') {
    var printstr = buffer.raw().toString('ascii');

    if (!this._isPrintstr(printstr)) {
      return buffer.error('Decoding of string type: ' + 'printstr unsupported characters');
    }

    return printstr;
  } else if (/str$/.test(tag)) {
    return buffer.raw().toString();
  } else {
    return buffer.error('Decoding of string type: ' + tag + ' unsupported');
  }
};

DERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {
  var result;
  var identifiers = [];
  var ident = 0;

  while (!buffer.isEmpty()) {
    var subident = buffer.readUInt8();
    ident <<= 7;
    ident |= subident & 0x7f;

    if ((subident & 0x80) === 0) {
      identifiers.push(ident);
      ident = 0;
    }
  }

  if (subident & 0x80) identifiers.push(ident);
  var first = identifiers[0] / 40 | 0;
  var second = identifiers[0] % 40;
  if (relative) result = identifiers;else result = [first, second].concat(identifiers.slice(1));

  if (values) {
    var tmp = values[result.join(' ')];
    if (tmp === undefined) tmp = values[result.join('.')];
    if (tmp !== undefined) result = tmp;
  }

  return result;
};

DERNode.prototype._decodeTime = function decodeTime(buffer, tag) {
  var str = buffer.raw().toString();

  if (tag === 'gentime') {
    var year = str.slice(0, 4) | 0;
    var mon = str.slice(4, 6) | 0;
    var day = str.slice(6, 8) | 0;
    var hour = str.slice(8, 10) | 0;
    var min = str.slice(10, 12) | 0;
    var sec = str.slice(12, 14) | 0;
  } else if (tag === 'utctime') {
    var year = str.slice(0, 2) | 0;
    var mon = str.slice(2, 4) | 0;
    var day = str.slice(4, 6) | 0;
    var hour = str.slice(6, 8) | 0;
    var min = str.slice(8, 10) | 0;
    var sec = str.slice(10, 12) | 0;
    if (year < 70) year = 2000 + year;else year = 1900 + year;
  } else {
    return buffer.error('Decoding ' + tag + ' time is not supported yet');
  }

  return Date.UTC(year, mon - 1, day, hour, min, sec, 0);
};

DERNode.prototype._decodeNull = function decodeNull(buffer) {
  return null;
};

DERNode.prototype._decodeBool = function decodeBool(buffer) {
  var res = buffer.readUInt8();
  if (buffer.isError(res)) return res;else return res !== 0;
};

DERNode.prototype._decodeInt = function decodeInt(buffer, values) {
  // Bigint, return as it is (assume big endian)
  var raw = buffer.raw();
  var res = new bignum(raw);
  if (values) res = values[res.toString(10)] || res;
  return res;
};

DERNode.prototype._use = function use(entity, obj) {
  if (typeof entity === 'function') entity = entity(obj);
  return entity._getDecoder('der').tree;
}; // Utility methods


function derDecodeTag(buf, fail) {
  var tag = buf.readUInt8(fail);
  if (buf.isError(tag)) return tag;
  var cls = der.tagClass[tag >> 6];
  var primitive = (tag & 0x20) === 0; // Multi-octet tag - load

  if ((tag & 0x1f) === 0x1f) {
    var oct = tag;
    tag = 0;

    while ((oct & 0x80) === 0x80) {
      oct = buf.readUInt8(fail);
      if (buf.isError(oct)) return oct;
      tag <<= 7;
      tag |= oct & 0x7f;
    }
  } else {
    tag &= 0x1f;
  }

  var tagStr = der.tag[tag];
  return {
    cls: cls,
    primitive: primitive,
    tag: tag,
    tagStr: tagStr
  };
}

function derDecodeLen(buf, primitive, fail) {
  var len = buf.readUInt8(fail);
  if (buf.isError(len)) return len; // Indefinite form

  if (!primitive && len === 0x80) return null; // Definite form

  if ((len & 0x80) === 0) {
    // Short form
    return len;
  } // Long form


  var num = len & 0x7f;
  if (num > 4) return buf.error('length octect is too long');
  len = 0;

  for (var i = 0; i < num; i++) {
    len <<= 8;
    var j = buf.readUInt8(fail);
    if (buf.isError(j)) return j;
    len |= j;
  }

  return len;
}

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/decoders/index.js":
/*!*********************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/decoders/index.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var decoders = exports;
decoders.der = __webpack_require__(/*! ./der */ "./node_modules/asn1.js/lib/asn1/decoders/der.js");
decoders.pem = __webpack_require__(/*! ./pem */ "./node_modules/asn1.js/lib/asn1/decoders/pem.js");

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/decoders/pem.js":
/*!*******************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/decoders/pem.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Buffer = __webpack_require__(/*! buffer */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer;

var DERDecoder = __webpack_require__(/*! ./der */ "./node_modules/asn1.js/lib/asn1/decoders/der.js");

function PEMDecoder(entity) {
  DERDecoder.call(this, entity);
  this.enc = 'pem';
}

;
inherits(PEMDecoder, DERDecoder);
module.exports = PEMDecoder;

PEMDecoder.prototype.decode = function decode(data, options) {
  var lines = data.toString().split(/[\r\n]+/g);
  var label = options.label.toUpperCase();
  var re = /^-----(BEGIN|END) ([^-]+)-----$/;
  var start = -1;
  var end = -1;

  for (var i = 0; i < lines.length; i++) {
    var match = lines[i].match(re);
    if (match === null) continue;
    if (match[2] !== label) continue;

    if (start === -1) {
      if (match[1] !== 'BEGIN') break;
      start = i;
    } else {
      if (match[1] !== 'END') break;
      end = i;
      break;
    }
  }

  if (start === -1 || end === -1) throw new Error('PEM section not found for: ' + label);
  var base64 = lines.slice(start + 1, end).join(''); // Remove excessive symbols

  base64.replace(/[^a-z0-9\+\/=]+/gi, '');
  var input = new Buffer(base64, 'base64');
  return DERDecoder.prototype.decode.call(this, input, options);
};

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/encoders/der.js":
/*!*******************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/encoders/der.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Buffer = __webpack_require__(/*! buffer */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer;

var asn1 = __webpack_require__(/*! ../../asn1 */ "./node_modules/asn1.js/lib/asn1.js");

var base = asn1.base; // Import DER constants

var der = asn1.constants.der;

function DEREncoder(entity) {
  this.enc = 'der';
  this.name = entity.name;
  this.entity = entity; // Construct base tree

  this.tree = new DERNode();

  this.tree._init(entity.body);
}

;
module.exports = DEREncoder;

DEREncoder.prototype.encode = function encode(data, reporter) {
  return this.tree._encode(data, reporter).join();
}; // Tree methods


function DERNode(parent) {
  base.Node.call(this, 'der', parent);
}

inherits(DERNode, base.Node);

DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) {
  var encodedTag = encodeTag(tag, primitive, cls, this.reporter); // Short form

  if (content.length < 0x80) {
    var header = new Buffer(2);
    header[0] = encodedTag;
    header[1] = content.length;
    return this._createEncoderBuffer([header, content]);
  } // Long form
  // Count octets required to store length


  var lenOctets = 1;

  for (var i = content.length; i >= 0x100; i >>= 8) {
    lenOctets++;
  }

  var header = new Buffer(1 + 1 + lenOctets);
  header[0] = encodedTag;
  header[1] = 0x80 | lenOctets;

  for (var i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8) {
    header[i] = j & 0xff;
  }

  return this._createEncoderBuffer([header, content]);
};

DERNode.prototype._encodeStr = function encodeStr(str, tag) {
  if (tag === 'bitstr') {
    return this._createEncoderBuffer([str.unused | 0, str.data]);
  } else if (tag === 'bmpstr') {
    var buf = new Buffer(str.length * 2);

    for (var i = 0; i < str.length; i++) {
      buf.writeUInt16BE(str.charCodeAt(i), i * 2);
    }

    return this._createEncoderBuffer(buf);
  } else if (tag === 'numstr') {
    if (!this._isNumstr(str)) {
      return this.reporter.error('Encoding of string type: numstr supports ' + 'only digits and space');
    }

    return this._createEncoderBuffer(str);
  } else if (tag === 'printstr') {
    if (!this._isPrintstr(str)) {
      return this.reporter.error('Encoding of string type: printstr supports ' + 'only latin upper and lower case letters, ' + 'digits, space, apostrophe, left and rigth ' + 'parenthesis, plus sign, comma, hyphen, ' + 'dot, slash, colon, equal sign, ' + 'question mark');
    }

    return this._createEncoderBuffer(str);
  } else if (/str$/.test(tag)) {
    return this._createEncoderBuffer(str);
  } else if (tag === 'objDesc') {
    return this._createEncoderBuffer(str);
  } else {
    return this.reporter.error('Encoding of string type: ' + tag + ' unsupported');
  }
};

DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
  if (typeof id === 'string') {
    if (!values) return this.reporter.error('string objid given, but no values map found');
    if (!values.hasOwnProperty(id)) return this.reporter.error('objid not found in values map');
    id = values[id].split(/[\s\.]+/g);

    for (var i = 0; i < id.length; i++) {
      id[i] |= 0;
    }
  } else if (Array.isArray(id)) {
    id = id.slice();

    for (var i = 0; i < id.length; i++) {
      id[i] |= 0;
    }
  }

  if (!Array.isArray(id)) {
    return this.reporter.error('objid() should be either array or string, ' + 'got: ' + JSON.stringify(id));
  }

  if (!relative) {
    if (id[1] >= 40) return this.reporter.error('Second objid identifier OOB');
    id.splice(0, 2, id[0] * 40 + id[1]);
  } // Count number of octets


  var size = 0;

  for (var i = 0; i < id.length; i++) {
    var ident = id[i];

    for (size++; ident >= 0x80; ident >>= 7) {
      size++;
    }
  }

  var objid = new Buffer(size);
  var offset = objid.length - 1;

  for (var i = id.length - 1; i >= 0; i--) {
    var ident = id[i];
    objid[offset--] = ident & 0x7f;

    while ((ident >>= 7) > 0) {
      objid[offset--] = 0x80 | ident & 0x7f;
    }
  }

  return this._createEncoderBuffer(objid);
};

function two(num) {
  if (num < 10) return '0' + num;else return num;
}

DERNode.prototype._encodeTime = function encodeTime(time, tag) {
  var str;
  var date = new Date(time);

  if (tag === 'gentime') {
    str = [two(date.getFullYear()), two(date.getUTCMonth() + 1), two(date.getUTCDate()), two(date.getUTCHours()), two(date.getUTCMinutes()), two(date.getUTCSeconds()), 'Z'].join('');
  } else if (tag === 'utctime') {
    str = [two(date.getFullYear() % 100), two(date.getUTCMonth() + 1), two(date.getUTCDate()), two(date.getUTCHours()), two(date.getUTCMinutes()), two(date.getUTCSeconds()), 'Z'].join('');
  } else {
    this.reporter.error('Encoding ' + tag + ' time is not supported yet');
  }

  return this._encodeStr(str, 'octstr');
};

DERNode.prototype._encodeNull = function encodeNull() {
  return this._createEncoderBuffer('');
};

DERNode.prototype._encodeInt = function encodeInt(num, values) {
  if (typeof num === 'string') {
    if (!values) return this.reporter.error('String int or enum given, but no values map');

    if (!values.hasOwnProperty(num)) {
      return this.reporter.error('Values map doesn\'t contain: ' + JSON.stringify(num));
    }

    num = values[num];
  } // Bignum, assume big endian


  if (typeof num !== 'number' && !Buffer.isBuffer(num)) {
    var numArray = num.toArray();

    if (!num.sign && numArray[0] & 0x80) {
      numArray.unshift(0);
    }

    num = new Buffer(numArray);
  }

  if (Buffer.isBuffer(num)) {
    var size = num.length;
    if (num.length === 0) size++;
    var out = new Buffer(size);
    num.copy(out);
    if (num.length === 0) out[0] = 0;
    return this._createEncoderBuffer(out);
  }

  if (num < 0x80) return this._createEncoderBuffer(num);
  if (num < 0x100) return this._createEncoderBuffer([0, num]);
  var size = 1;

  for (var i = num; i >= 0x100; i >>= 8) {
    size++;
  }

  var out = new Array(size);

  for (var i = out.length - 1; i >= 0; i--) {
    out[i] = num & 0xff;
    num >>= 8;
  }

  if (out[0] & 0x80) {
    out.unshift(0);
  }

  return this._createEncoderBuffer(new Buffer(out));
};

DERNode.prototype._encodeBool = function encodeBool(value) {
  return this._createEncoderBuffer(value ? 0xff : 0);
};

DERNode.prototype._use = function use(entity, obj) {
  if (typeof entity === 'function') entity = entity(obj);
  return entity._getEncoder('der').tree;
};

DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {
  var state = this._baseState;
  var i;
  if (state['default'] === null) return false;
  var data = dataBuffer.join();
  if (state.defaultBuffer === undefined) state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();
  if (data.length !== state.defaultBuffer.length) return false;

  for (i = 0; i < data.length; i++) {
    if (data[i] !== state.defaultBuffer[i]) return false;
  }

  return true;
}; // Utility methods


function encodeTag(tag, primitive, cls, reporter) {
  var res;
  if (tag === 'seqof') tag = 'seq';else if (tag === 'setof') tag = 'set';
  if (der.tagByName.hasOwnProperty(tag)) res = der.tagByName[tag];else if (typeof tag === 'number' && (tag | 0) === tag) res = tag;else return reporter.error('Unknown tag: ' + tag);
  if (res >= 0x1f) return reporter.error('Multi-octet tag encoding unsupported');
  if (!primitive) res |= 0x20;
  res |= der.tagClassByName[cls || 'universal'] << 6;
  return res;
}

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/encoders/index.js":
/*!*********************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/encoders/index.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var encoders = exports;
encoders.der = __webpack_require__(/*! ./der */ "./node_modules/asn1.js/lib/asn1/encoders/der.js");
encoders.pem = __webpack_require__(/*! ./pem */ "./node_modules/asn1.js/lib/asn1/encoders/pem.js");

/***/ }),

/***/ "./node_modules/asn1.js/lib/asn1/encoders/pem.js":
/*!*******************************************************!*\
  !*** ./node_modules/asn1.js/lib/asn1/encoders/pem.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var DEREncoder = __webpack_require__(/*! ./der */ "./node_modules/asn1.js/lib/asn1/encoders/der.js");

function PEMEncoder(entity) {
  DEREncoder.call(this, entity);
  this.enc = 'pem';
}

;
inherits(PEMEncoder, DEREncoder);
module.exports = PEMEncoder;

PEMEncoder.prototype.encode = function encode(data, options) {
  var buf = DEREncoder.prototype.encode.call(this, data);
  var p = buf.toString('base64');
  var out = ['-----BEGIN ' + options.label + '-----'];

  for (var i = 0; i < p.length; i += 64) {
    out.push(p.slice(i, i + 64));
  }

  out.push('-----END ' + options.label + '-----');
  return out.join('\n');
};

/***/ }),

/***/ "./node_modules/bn.js/lib/bn.js":
/*!**************************************!*\
  !*** ./node_modules/bn.js/lib/bn.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(module) {function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

(function (module, exports) {
  'use strict'; // Utils

  function assert(val, msg) {
    if (!val) throw new Error(msg || 'Assertion failed');
  } // Could use `inherits` module, but don't want to move from single file
  // architecture yet.


  function inherits(ctor, superCtor) {
    ctor.super_ = superCtor;

    var TempCtor = function TempCtor() {};

    TempCtor.prototype = superCtor.prototype;
    ctor.prototype = new TempCtor();
    ctor.prototype.constructor = ctor;
  } // BN


  function BN(number, base, endian) {
    if (BN.isBN(number)) {
      return number;
    }

    this.negative = 0;
    this.words = null;
    this.length = 0; // Reduction context

    this.red = null;

    if (number !== null) {
      if (base === 'le' || base === 'be') {
        endian = base;
        base = 10;
      }

      this._init(number || 0, base || 10, endian || 'be');
    }
  }

  if (_typeof(module) === 'object') {
    module.exports = BN;
  } else {
    exports.BN = BN;
  }

  BN.BN = BN;
  BN.wordSize = 26;
  var Buffer;

  try {
    Buffer = __webpack_require__(/*! buffer */ 3).Buffer;
  } catch (e) {}

  BN.isBN = function isBN(num) {
    if (num instanceof BN) {
      return true;
    }

    return num !== null && _typeof(num) === 'object' && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
  };

  BN.max = function max(left, right) {
    if (left.cmp(right) > 0) return left;
    return right;
  };

  BN.min = function min(left, right) {
    if (left.cmp(right) < 0) return left;
    return right;
  };

  BN.prototype._init = function init(number, base, endian) {
    if (typeof number === 'number') {
      return this._initNumber(number, base, endian);
    }

    if (_typeof(number) === 'object') {
      return this._initArray(number, base, endian);
    }

    if (base === 'hex') {
      base = 16;
    }

    assert(base === (base | 0) && base >= 2 && base <= 36);
    number = number.toString().replace(/\s+/g, '');
    var start = 0;

    if (number[0] === '-') {
      start++;
    }

    if (base === 16) {
      this._parseHex(number, start);
    } else {
      this._parseBase(number, base, start);
    }

    if (number[0] === '-') {
      this.negative = 1;
    }

    this.strip();
    if (endian !== 'le') return;

    this._initArray(this.toArray(), base, endian);
  };

  BN.prototype._initNumber = function _initNumber(number, base, endian) {
    if (number < 0) {
      this.negative = 1;
      number = -number;
    }

    if (number < 0x4000000) {
      this.words = [number & 0x3ffffff];
      this.length = 1;
    } else if (number < 0x10000000000000) {
      this.words = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff];
      this.length = 2;
    } else {
      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)

      this.words = [number & 0x3ffffff, number / 0x4000000 & 0x3ffffff, 1];
      this.length = 3;
    }

    if (endian !== 'le') return; // Reverse the bytes

    this._initArray(this.toArray(), base, endian);
  };

  BN.prototype._initArray = function _initArray(number, base, endian) {
    // Perhaps a Uint8Array
    assert(typeof number.length === 'number');

    if (number.length <= 0) {
      this.words = [0];
      this.length = 1;
      return this;
    }

    this.length = Math.ceil(number.length / 3);
    this.words = new Array(this.length);

    for (var i = 0; i < this.length; i++) {
      this.words[i] = 0;
    }

    var j, w;
    var off = 0;

    if (endian === 'be') {
      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
        w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
        this.words[j] |= w << off & 0x3ffffff;
        this.words[j + 1] = w >>> 26 - off & 0x3ffffff;
        off += 24;

        if (off >= 26) {
          off -= 26;
          j++;
        }
      }
    } else if (endian === 'le') {
      for (i = 0, j = 0; i < number.length; i += 3) {
        w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
        this.words[j] |= w << off & 0x3ffffff;
        this.words[j + 1] = w >>> 26 - off & 0x3ffffff;
        off += 24;

        if (off >= 26) {
          off -= 26;
          j++;
        }
      }
    }

    return this.strip();
  };

  function parseHex(str, start, end) {
    var r = 0;
    var len = Math.min(str.length, end);

    for (var i = start; i < len; i++) {
      var c = str.charCodeAt(i) - 48;
      r <<= 4; // 'a' - 'f'

      if (c >= 49 && c <= 54) {
        r |= c - 49 + 0xa; // 'A' - 'F'
      } else if (c >= 17 && c <= 22) {
        r |= c - 17 + 0xa; // '0' - '9'
      } else {
        r |= c & 0xf;
      }
    }

    return r;
  }

  BN.prototype._parseHex = function _parseHex(number, start) {
    // Create possibly bigger array to ensure that it fits the number
    this.length = Math.ceil((number.length - start) / 6);
    this.words = new Array(this.length);

    for (var i = 0; i < this.length; i++) {
      this.words[i] = 0;
    }

    var j, w; // Scan 24-bit chunks and add them to the number

    var off = 0;

    for (i = number.length - 6, j = 0; i >= start; i -= 6) {
      w = parseHex(number, i, i + 6);
      this.words[j] |= w << off & 0x3ffffff; // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb

      this.words[j + 1] |= w >>> 26 - off & 0x3fffff;
      off += 24;

      if (off >= 26) {
        off -= 26;
        j++;
      }
    }

    if (i + 6 !== start) {
      w = parseHex(number, start, i + 6);
      this.words[j] |= w << off & 0x3ffffff;
      this.words[j + 1] |= w >>> 26 - off & 0x3fffff;
    }

    this.strip();
  };

  function parseBase(str, start, end, mul) {
    var r = 0;
    var len = Math.min(str.length, end);

    for (var i = start; i < len; i++) {
      var c = str.charCodeAt(i) - 48;
      r *= mul; // 'a'

      if (c >= 49) {
        r += c - 49 + 0xa; // 'A'
      } else if (c >= 17) {
        r += c - 17 + 0xa; // '0' - '9'
      } else {
        r += c;
      }
    }

    return r;
  }

  BN.prototype._parseBase = function _parseBase(number, base, start) {
    // Initialize as zero
    this.words = [0];
    this.length = 1; // Find length of limb in base

    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
      limbLen++;
    }

    limbLen--;
    limbPow = limbPow / base | 0;
    var total = number.length - start;
    var mod = total % limbLen;
    var end = Math.min(total, total - mod) + start;
    var word = 0;

    for (var i = start; i < end; i += limbLen) {
      word = parseBase(number, i, i + limbLen, base);
      this.imuln(limbPow);

      if (this.words[0] + word < 0x4000000) {
        this.words[0] += word;
      } else {
        this._iaddn(word);
      }
    }

    if (mod !== 0) {
      var pow = 1;
      word = parseBase(number, i, number.length, base);

      for (i = 0; i < mod; i++) {
        pow *= base;
      }

      this.imuln(pow);

      if (this.words[0] + word < 0x4000000) {
        this.words[0] += word;
      } else {
        this._iaddn(word);
      }
    }
  };

  BN.prototype.copy = function copy(dest) {
    dest.words = new Array(this.length);

    for (var i = 0; i < this.length; i++) {
      dest.words[i] = this.words[i];
    }

    dest.length = this.length;
    dest.negative = this.negative;
    dest.red = this.red;
  };

  BN.prototype.clone = function clone() {
    var r = new BN(null);
    this.copy(r);
    return r;
  };

  BN.prototype._expand = function _expand(size) {
    while (this.length < size) {
      this.words[this.length++] = 0;
    }

    return this;
  }; // Remove leading `0` from `this`


  BN.prototype.strip = function strip() {
    while (this.length > 1 && this.words[this.length - 1] === 0) {
      this.length--;
    }

    return this._normSign();
  };

  BN.prototype._normSign = function _normSign() {
    // -0 = 0
    if (this.length === 1 && this.words[0] === 0) {
      this.negative = 0;
    }

    return this;
  };

  BN.prototype.inspect = function inspect() {
    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
  };
  /*
   var zeros = [];
  var groupSizes = [];
  var groupBases = [];
   var s = '';
  var i = -1;
  while (++i < BN.wordSize) {
    zeros[i] = s;
    s += '0';
  }
  groupSizes[0] = 0;
  groupSizes[1] = 0;
  groupBases[0] = 0;
  groupBases[1] = 0;
  var base = 2 - 1;
  while (++base < 36 + 1) {
    var groupSize = 0;
    var groupBase = 1;
    while (groupBase < (1 << BN.wordSize) / base) {
      groupBase *= base;
      groupSize += 1;
    }
    groupSizes[base] = groupSize;
    groupBases[base] = groupBase;
  }
   */


  var zeros = ['', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000', '000000000', '0000000000', '00000000000', '000000000000', '0000000000000', '00000000000000', '000000000000000', '0000000000000000', '00000000000000000', '000000000000000000', '0000000000000000000', '00000000000000000000', '000000000000000000000', '0000000000000000000000', '00000000000000000000000', '000000000000000000000000', '0000000000000000000000000'];
  var groupSizes = [0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5];
  var groupBases = [0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176];

  BN.prototype.toString = function toString(base, padding) {
    base = base || 10;
    padding = padding | 0 || 1;
    var out;

    if (base === 16 || base === 'hex') {
      out = '';
      var off = 0;
      var carry = 0;

      for (var i = 0; i < this.length; i++) {
        var w = this.words[i];
        var word = ((w << off | carry) & 0xffffff).toString(16);
        carry = w >>> 24 - off & 0xffffff;

        if (carry !== 0 || i !== this.length - 1) {
          out = zeros[6 - word.length] + word + out;
        } else {
          out = word + out;
        }

        off += 2;

        if (off >= 26) {
          off -= 26;
          i--;
        }
      }

      if (carry !== 0) {
        out = carry.toString(16) + out;
      }

      while (out.length % padding !== 0) {
        out = '0' + out;
      }

      if (this.negative !== 0) {
        out = '-' + out;
      }

      return out;
    }

    if (base === (base | 0) && base >= 2 && base <= 36) {
      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
      var groupSize = groupSizes[base]; // var groupBase = Math.pow(base, groupSize);

      var groupBase = groupBases[base];
      out = '';
      var c = this.clone();
      c.negative = 0;

      while (!c.isZero()) {
        var r = c.modn(groupBase).toString(base);
        c = c.idivn(groupBase);

        if (!c.isZero()) {
          out = zeros[groupSize - r.length] + r + out;
        } else {
          out = r + out;
        }
      }

      if (this.isZero()) {
        out = '0' + out;
      }

      while (out.length % padding !== 0) {
        out = '0' + out;
      }

      if (this.negative !== 0) {
        out = '-' + out;
      }

      return out;
    }

    assert(false, 'Base should be between 2 and 36');
  };

  BN.prototype.toNumber = function toNumber() {
    var ret = this.words[0];

    if (this.length === 2) {
      ret += this.words[1] * 0x4000000;
    } else if (this.length === 3 && this.words[2] === 0x01) {
      // NOTE: at this stage it is known that the top bit is set
      ret += 0x10000000000000 + this.words[1] * 0x4000000;
    } else if (this.length > 2) {
      assert(false, 'Number can only safely store up to 53 bits');
    }

    return this.negative !== 0 ? -ret : ret;
  };

  BN.prototype.toJSON = function toJSON() {
    return this.toString(16);
  };

  BN.prototype.toBuffer = function toBuffer(endian, length) {
    assert(typeof Buffer !== 'undefined');
    return this.toArrayLike(Buffer, endian, length);
  };

  BN.prototype.toArray = function toArray(endian, length) {
    return this.toArrayLike(Array, endian, length);
  };

  BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
    var byteLength = this.byteLength();
    var reqLength = length || Math.max(1, byteLength);
    assert(byteLength <= reqLength, 'byte array longer than desired length');
    assert(reqLength > 0, 'Requested array length <= 0');
    this.strip();
    var littleEndian = endian === 'le';
    var res = new ArrayType(reqLength);
    var b, i;
    var q = this.clone();

    if (!littleEndian) {
      // Assume big-endian
      for (i = 0; i < reqLength - byteLength; i++) {
        res[i] = 0;
      }

      for (i = 0; !q.isZero(); i++) {
        b = q.andln(0xff);
        q.iushrn(8);
        res[reqLength - i - 1] = b;
      }
    } else {
      for (i = 0; !q.isZero(); i++) {
        b = q.andln(0xff);
        q.iushrn(8);
        res[i] = b;
      }

      for (; i < reqLength; i++) {
        res[i] = 0;
      }
    }

    return res;
  };

  if (Math.clz32) {
    BN.prototype._countBits = function _countBits(w) {
      return 32 - Math.clz32(w);
    };
  } else {
    BN.prototype._countBits = function _countBits(w) {
      var t = w;
      var r = 0;

      if (t >= 0x1000) {
        r += 13;
        t >>>= 13;
      }

      if (t >= 0x40) {
        r += 7;
        t >>>= 7;
      }

      if (t >= 0x8) {
        r += 4;
        t >>>= 4;
      }

      if (t >= 0x02) {
        r += 2;
        t >>>= 2;
      }

      return r + t;
    };
  }

  BN.prototype._zeroBits = function _zeroBits(w) {
    // Short-cut
    if (w === 0) return 26;
    var t = w;
    var r = 0;

    if ((t & 0x1fff) === 0) {
      r += 13;
      t >>>= 13;
    }

    if ((t & 0x7f) === 0) {
      r += 7;
      t >>>= 7;
    }

    if ((t & 0xf) === 0) {
      r += 4;
      t >>>= 4;
    }

    if ((t & 0x3) === 0) {
      r += 2;
      t >>>= 2;
    }

    if ((t & 0x1) === 0) {
      r++;
    }

    return r;
  }; // Return number of used bits in a BN


  BN.prototype.bitLength = function bitLength() {
    var w = this.words[this.length - 1];

    var hi = this._countBits(w);

    return (this.length - 1) * 26 + hi;
  };

  function toBitArray(num) {
    var w = new Array(num.bitLength());

    for (var bit = 0; bit < w.length; bit++) {
      var off = bit / 26 | 0;
      var wbit = bit % 26;
      w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
    }

    return w;
  } // Number of trailing zero bits


  BN.prototype.zeroBits = function zeroBits() {
    if (this.isZero()) return 0;
    var r = 0;

    for (var i = 0; i < this.length; i++) {
      var b = this._zeroBits(this.words[i]);

      r += b;
      if (b !== 26) break;
    }

    return r;
  };

  BN.prototype.byteLength = function byteLength() {
    return Math.ceil(this.bitLength() / 8);
  };

  BN.prototype.toTwos = function toTwos(width) {
    if (this.negative !== 0) {
      return this.abs().inotn(width).iaddn(1);
    }

    return this.clone();
  };

  BN.prototype.fromTwos = function fromTwos(width) {
    if (this.testn(width - 1)) {
      return this.notn(width).iaddn(1).ineg();
    }

    return this.clone();
  };

  BN.prototype.isNeg = function isNeg() {
    return this.negative !== 0;
  }; // Return negative clone of `this`


  BN.prototype.neg = function neg() {
    return this.clone().ineg();
  };

  BN.prototype.ineg = function ineg() {
    if (!this.isZero()) {
      this.negative ^= 1;
    }

    return this;
  }; // Or `num` with `this` in-place


  BN.prototype.iuor = function iuor(num) {
    while (this.length < num.length) {
      this.words[this.length++] = 0;
    }

    for (var i = 0; i < num.length; i++) {
      this.words[i] = this.words[i] | num.words[i];
    }

    return this.strip();
  };

  BN.prototype.ior = function ior(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuor(num);
  }; // Or `num` with `this`


  BN.prototype.or = function or(num) {
    if (this.length > num.length) return this.clone().ior(num);
    return num.clone().ior(this);
  };

  BN.prototype.uor = function uor(num) {
    if (this.length > num.length) return this.clone().iuor(num);
    return num.clone().iuor(this);
  }; // And `num` with `this` in-place


  BN.prototype.iuand = function iuand(num) {
    // b = min-length(num, this)
    var b;

    if (this.length > num.length) {
      b = num;
    } else {
      b = this;
    }

    for (var i = 0; i < b.length; i++) {
      this.words[i] = this.words[i] & num.words[i];
    }

    this.length = b.length;
    return this.strip();
  };

  BN.prototype.iand = function iand(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuand(num);
  }; // And `num` with `this`


  BN.prototype.and = function and(num) {
    if (this.length > num.length) return this.clone().iand(num);
    return num.clone().iand(this);
  };

  BN.prototype.uand = function uand(num) {
    if (this.length > num.length) return this.clone().iuand(num);
    return num.clone().iuand(this);
  }; // Xor `num` with `this` in-place


  BN.prototype.iuxor = function iuxor(num) {
    // a.length > b.length
    var a;
    var b;

    if (this.length > num.length) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }

    for (var i = 0; i < b.length; i++) {
      this.words[i] = a.words[i] ^ b.words[i];
    }

    if (this !== a) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }

    this.length = a.length;
    return this.strip();
  };

  BN.prototype.ixor = function ixor(num) {
    assert((this.negative | num.negative) === 0);
    return this.iuxor(num);
  }; // Xor `num` with `this`


  BN.prototype.xor = function xor(num) {
    if (this.length > num.length) return this.clone().ixor(num);
    return num.clone().ixor(this);
  };

  BN.prototype.uxor = function uxor(num) {
    if (this.length > num.length) return this.clone().iuxor(num);
    return num.clone().iuxor(this);
  }; // Not ``this`` with ``width`` bitwidth


  BN.prototype.inotn = function inotn(width) {
    assert(typeof width === 'number' && width >= 0);
    var bytesNeeded = Math.ceil(width / 26) | 0;
    var bitsLeft = width % 26; // Extend the buffer with leading zeroes

    this._expand(bytesNeeded);

    if (bitsLeft > 0) {
      bytesNeeded--;
    } // Handle complete words


    for (var i = 0; i < bytesNeeded; i++) {
      this.words[i] = ~this.words[i] & 0x3ffffff;
    } // Handle the residue


    if (bitsLeft > 0) {
      this.words[i] = ~this.words[i] & 0x3ffffff >> 26 - bitsLeft;
    } // And remove leading zeroes


    return this.strip();
  };

  BN.prototype.notn = function notn(width) {
    return this.clone().inotn(width);
  }; // Set `bit` of `this`


  BN.prototype.setn = function setn(bit, val) {
    assert(typeof bit === 'number' && bit >= 0);
    var off = bit / 26 | 0;
    var wbit = bit % 26;

    this._expand(off + 1);

    if (val) {
      this.words[off] = this.words[off] | 1 << wbit;
    } else {
      this.words[off] = this.words[off] & ~(1 << wbit);
    }

    return this.strip();
  }; // Add `num` to `this` in-place


  BN.prototype.iadd = function iadd(num) {
    var r; // negative + positive

    if (this.negative !== 0 && num.negative === 0) {
      this.negative = 0;
      r = this.isub(num);
      this.negative ^= 1;
      return this._normSign(); // positive + negative
    } else if (this.negative === 0 && num.negative !== 0) {
      num.negative = 0;
      r = this.isub(num);
      num.negative = 1;
      return r._normSign();
    } // a.length > b.length


    var a, b;

    if (this.length > num.length) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }

    var carry = 0;

    for (var i = 0; i < b.length; i++) {
      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
      this.words[i] = r & 0x3ffffff;
      carry = r >>> 26;
    }

    for (; carry !== 0 && i < a.length; i++) {
      r = (a.words[i] | 0) + carry;
      this.words[i] = r & 0x3ffffff;
      carry = r >>> 26;
    }

    this.length = a.length;

    if (carry !== 0) {
      this.words[this.length] = carry;
      this.length++; // Copy the rest of the words
    } else if (a !== this) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }

    return this;
  }; // Add `num` to `this`


  BN.prototype.add = function add(num) {
    var res;

    if (num.negative !== 0 && this.negative === 0) {
      num.negative = 0;
      res = this.sub(num);
      num.negative ^= 1;
      return res;
    } else if (num.negative === 0 && this.negative !== 0) {
      this.negative = 0;
      res = num.sub(this);
      this.negative = 1;
      return res;
    }

    if (this.length > num.length) return this.clone().iadd(num);
    return num.clone().iadd(this);
  }; // Subtract `num` from `this` in-place


  BN.prototype.isub = function isub(num) {
    // this - (-num) = this + num
    if (num.negative !== 0) {
      num.negative = 0;
      var r = this.iadd(num);
      num.negative = 1;
      return r._normSign(); // -this - num = -(this + num)
    } else if (this.negative !== 0) {
      this.negative = 0;
      this.iadd(num);
      this.negative = 1;
      return this._normSign();
    } // At this point both numbers are positive


    var cmp = this.cmp(num); // Optimization - zeroify

    if (cmp === 0) {
      this.negative = 0;
      this.length = 1;
      this.words[0] = 0;
      return this;
    } // a > b


    var a, b;

    if (cmp > 0) {
      a = this;
      b = num;
    } else {
      a = num;
      b = this;
    }

    var carry = 0;

    for (var i = 0; i < b.length; i++) {
      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
      carry = r >> 26;
      this.words[i] = r & 0x3ffffff;
    }

    for (; carry !== 0 && i < a.length; i++) {
      r = (a.words[i] | 0) + carry;
      carry = r >> 26;
      this.words[i] = r & 0x3ffffff;
    } // Copy rest of the words


    if (carry === 0 && i < a.length && a !== this) {
      for (; i < a.length; i++) {
        this.words[i] = a.words[i];
      }
    }

    this.length = Math.max(this.length, i);

    if (a !== this) {
      this.negative = 1;
    }

    return this.strip();
  }; // Subtract `num` from `this`


  BN.prototype.sub = function sub(num) {
    return this.clone().isub(num);
  };

  function smallMulTo(self, num, out) {
    out.negative = num.negative ^ self.negative;
    var len = self.length + num.length | 0;
    out.length = len;
    len = len - 1 | 0; // Peel one iteration (compiler can't do it, because of code complexity)

    var a = self.words[0] | 0;
    var b = num.words[0] | 0;
    var r = a * b;
    var lo = r & 0x3ffffff;
    var carry = r / 0x4000000 | 0;
    out.words[0] = lo;

    for (var k = 1; k < len; k++) {
      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
      // note that ncarry could be >= 0x3ffffff
      var ncarry = carry >>> 26;
      var rword = carry & 0x3ffffff;
      var maxJ = Math.min(k, num.length - 1);

      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
        var i = k - j | 0;
        a = self.words[i] | 0;
        b = num.words[j] | 0;
        r = a * b + rword;
        ncarry += r / 0x4000000 | 0;
        rword = r & 0x3ffffff;
      }

      out.words[k] = rword | 0;
      carry = ncarry | 0;
    }

    if (carry !== 0) {
      out.words[k] = carry | 0;
    } else {
      out.length--;
    }

    return out.strip();
  } // TODO(indutny): it may be reasonable to omit it for users who don't need
  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
  // multiplication (like elliptic secp256k1).


  var comb10MulTo = function comb10MulTo(self, num, out) {
    var a = self.words;
    var b = num.words;
    var o = out.words;
    var c = 0;
    var lo;
    var mid;
    var hi;
    var a0 = a[0] | 0;
    var al0 = a0 & 0x1fff;
    var ah0 = a0 >>> 13;
    var a1 = a[1] | 0;
    var al1 = a1 & 0x1fff;
    var ah1 = a1 >>> 13;
    var a2 = a[2] | 0;
    var al2 = a2 & 0x1fff;
    var ah2 = a2 >>> 13;
    var a3 = a[3] | 0;
    var al3 = a3 & 0x1fff;
    var ah3 = a3 >>> 13;
    var a4 = a[4] | 0;
    var al4 = a4 & 0x1fff;
    var ah4 = a4 >>> 13;
    var a5 = a[5] | 0;
    var al5 = a5 & 0x1fff;
    var ah5 = a5 >>> 13;
    var a6 = a[6] | 0;
    var al6 = a6 & 0x1fff;
    var ah6 = a6 >>> 13;
    var a7 = a[7] | 0;
    var al7 = a7 & 0x1fff;
    var ah7 = a7 >>> 13;
    var a8 = a[8] | 0;
    var al8 = a8 & 0x1fff;
    var ah8 = a8 >>> 13;
    var a9 = a[9] | 0;
    var al9 = a9 & 0x1fff;
    var ah9 = a9 >>> 13;
    var b0 = b[0] | 0;
    var bl0 = b0 & 0x1fff;
    var bh0 = b0 >>> 13;
    var b1 = b[1] | 0;
    var bl1 = b1 & 0x1fff;
    var bh1 = b1 >>> 13;
    var b2 = b[2] | 0;
    var bl2 = b2 & 0x1fff;
    var bh2 = b2 >>> 13;
    var b3 = b[3] | 0;
    var bl3 = b3 & 0x1fff;
    var bh3 = b3 >>> 13;
    var b4 = b[4] | 0;
    var bl4 = b4 & 0x1fff;
    var bh4 = b4 >>> 13;
    var b5 = b[5] | 0;
    var bl5 = b5 & 0x1fff;
    var bh5 = b5 >>> 13;
    var b6 = b[6] | 0;
    var bl6 = b6 & 0x1fff;
    var bh6 = b6 >>> 13;
    var b7 = b[7] | 0;
    var bl7 = b7 & 0x1fff;
    var bh7 = b7 >>> 13;
    var b8 = b[8] | 0;
    var bl8 = b8 & 0x1fff;
    var bh8 = b8 >>> 13;
    var b9 = b[9] | 0;
    var bl9 = b9 & 0x1fff;
    var bh9 = b9 >>> 13;
    out.negative = self.negative ^ num.negative;
    out.length = 19;
    /* k = 0 */

    lo = Math.imul(al0, bl0);
    mid = Math.imul(al0, bh0);
    mid = mid + Math.imul(ah0, bl0) | 0;
    hi = Math.imul(ah0, bh0);
    var w0 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
    w0 &= 0x3ffffff;
    /* k = 1 */

    lo = Math.imul(al1, bl0);
    mid = Math.imul(al1, bh0);
    mid = mid + Math.imul(ah1, bl0) | 0;
    hi = Math.imul(ah1, bh0);
    lo = lo + Math.imul(al0, bl1) | 0;
    mid = mid + Math.imul(al0, bh1) | 0;
    mid = mid + Math.imul(ah0, bl1) | 0;
    hi = hi + Math.imul(ah0, bh1) | 0;
    var w1 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
    w1 &= 0x3ffffff;
    /* k = 2 */

    lo = Math.imul(al2, bl0);
    mid = Math.imul(al2, bh0);
    mid = mid + Math.imul(ah2, bl0) | 0;
    hi = Math.imul(ah2, bh0);
    lo = lo + Math.imul(al1, bl1) | 0;
    mid = mid + Math.imul(al1, bh1) | 0;
    mid = mid + Math.imul(ah1, bl1) | 0;
    hi = hi + Math.imul(ah1, bh1) | 0;
    lo = lo + Math.imul(al0, bl2) | 0;
    mid = mid + Math.imul(al0, bh2) | 0;
    mid = mid + Math.imul(ah0, bl2) | 0;
    hi = hi + Math.imul(ah0, bh2) | 0;
    var w2 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
    w2 &= 0x3ffffff;
    /* k = 3 */

    lo = Math.imul(al3, bl0);
    mid = Math.imul(al3, bh0);
    mid = mid + Math.imul(ah3, bl0) | 0;
    hi = Math.imul(ah3, bh0);
    lo = lo + Math.imul(al2, bl1) | 0;
    mid = mid + Math.imul(al2, bh1) | 0;
    mid = mid + Math.imul(ah2, bl1) | 0;
    hi = hi + Math.imul(ah2, bh1) | 0;
    lo = lo + Math.imul(al1, bl2) | 0;
    mid = mid + Math.imul(al1, bh2) | 0;
    mid = mid + Math.imul(ah1, bl2) | 0;
    hi = hi + Math.imul(ah1, bh2) | 0;
    lo = lo + Math.imul(al0, bl3) | 0;
    mid = mid + Math.imul(al0, bh3) | 0;
    mid = mid + Math.imul(ah0, bl3) | 0;
    hi = hi + Math.imul(ah0, bh3) | 0;
    var w3 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
    w3 &= 0x3ffffff;
    /* k = 4 */

    lo = Math.imul(al4, bl0);
    mid = Math.imul(al4, bh0);
    mid = mid + Math.imul(ah4, bl0) | 0;
    hi = Math.imul(ah4, bh0);
    lo = lo + Math.imul(al3, bl1) | 0;
    mid = mid + Math.imul(al3, bh1) | 0;
    mid = mid + Math.imul(ah3, bl1) | 0;
    hi = hi + Math.imul(ah3, bh1) | 0;
    lo = lo + Math.imul(al2, bl2) | 0;
    mid = mid + Math.imul(al2, bh2) | 0;
    mid = mid + Math.imul(ah2, bl2) | 0;
    hi = hi + Math.imul(ah2, bh2) | 0;
    lo = lo + Math.imul(al1, bl3) | 0;
    mid = mid + Math.imul(al1, bh3) | 0;
    mid = mid + Math.imul(ah1, bl3) | 0;
    hi = hi + Math.imul(ah1, bh3) | 0;
    lo = lo + Math.imul(al0, bl4) | 0;
    mid = mid + Math.imul(al0, bh4) | 0;
    mid = mid + Math.imul(ah0, bl4) | 0;
    hi = hi + Math.imul(ah0, bh4) | 0;
    var w4 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
    w4 &= 0x3ffffff;
    /* k = 5 */

    lo = Math.imul(al5, bl0);
    mid = Math.imul(al5, bh0);
    mid = mid + Math.imul(ah5, bl0) | 0;
    hi = Math.imul(ah5, bh0);
    lo = lo + Math.imul(al4, bl1) | 0;
    mid = mid + Math.imul(al4, bh1) | 0;
    mid = mid + Math.imul(ah4, bl1) | 0;
    hi = hi + Math.imul(ah4, bh1) | 0;
    lo = lo + Math.imul(al3, bl2) | 0;
    mid = mid + Math.imul(al3, bh2) | 0;
    mid = mid + Math.imul(ah3, bl2) | 0;
    hi = hi + Math.imul(ah3, bh2) | 0;
    lo = lo + Math.imul(al2, bl3) | 0;
    mid = mid + Math.imul(al2, bh3) | 0;
    mid = mid + Math.imul(ah2, bl3) | 0;
    hi = hi + Math.imul(ah2, bh3) | 0;
    lo = lo + Math.imul(al1, bl4) | 0;
    mid = mid + Math.imul(al1, bh4) | 0;
    mid = mid + Math.imul(ah1, bl4) | 0;
    hi = hi + Math.imul(ah1, bh4) | 0;
    lo = lo + Math.imul(al0, bl5) | 0;
    mid = mid + Math.imul(al0, bh5) | 0;
    mid = mid + Math.imul(ah0, bl5) | 0;
    hi = hi + Math.imul(ah0, bh5) | 0;
    var w5 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
    w5 &= 0x3ffffff;
    /* k = 6 */

    lo = Math.imul(al6, bl0);
    mid = Math.imul(al6, bh0);
    mid = mid + Math.imul(ah6, bl0) | 0;
    hi = Math.imul(ah6, bh0);
    lo = lo + Math.imul(al5, bl1) | 0;
    mid = mid + Math.imul(al5, bh1) | 0;
    mid = mid + Math.imul(ah5, bl1) | 0;
    hi = hi + Math.imul(ah5, bh1) | 0;
    lo = lo + Math.imul(al4, bl2) | 0;
    mid = mid + Math.imul(al4, bh2) | 0;
    mid = mid + Math.imul(ah4, bl2) | 0;
    hi = hi + Math.imul(ah4, bh2) | 0;
    lo = lo + Math.imul(al3, bl3) | 0;
    mid = mid + Math.imul(al3, bh3) | 0;
    mid = mid + Math.imul(ah3, bl3) | 0;
    hi = hi + Math.imul(ah3, bh3) | 0;
    lo = lo + Math.imul(al2, bl4) | 0;
    mid = mid + Math.imul(al2, bh4) | 0;
    mid = mid + Math.imul(ah2, bl4) | 0;
    hi = hi + Math.imul(ah2, bh4) | 0;
    lo = lo + Math.imul(al1, bl5) | 0;
    mid = mid + Math.imul(al1, bh5) | 0;
    mid = mid + Math.imul(ah1, bl5) | 0;
    hi = hi + Math.imul(ah1, bh5) | 0;
    lo = lo + Math.imul(al0, bl6) | 0;
    mid = mid + Math.imul(al0, bh6) | 0;
    mid = mid + Math.imul(ah0, bl6) | 0;
    hi = hi + Math.imul(ah0, bh6) | 0;
    var w6 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
    w6 &= 0x3ffffff;
    /* k = 7 */

    lo = Math.imul(al7, bl0);
    mid = Math.imul(al7, bh0);
    mid = mid + Math.imul(ah7, bl0) | 0;
    hi = Math.imul(ah7, bh0);
    lo = lo + Math.imul(al6, bl1) | 0;
    mid = mid + Math.imul(al6, bh1) | 0;
    mid = mid + Math.imul(ah6, bl1) | 0;
    hi = hi + Math.imul(ah6, bh1) | 0;
    lo = lo + Math.imul(al5, bl2) | 0;
    mid = mid + Math.imul(al5, bh2) | 0;
    mid = mid + Math.imul(ah5, bl2) | 0;
    hi = hi + Math.imul(ah5, bh2) | 0;
    lo = lo + Math.imul(al4, bl3) | 0;
    mid = mid + Math.imul(al4, bh3) | 0;
    mid = mid + Math.imul(ah4, bl3) | 0;
    hi = hi + Math.imul(ah4, bh3) | 0;
    lo = lo + Math.imul(al3, bl4) | 0;
    mid = mid + Math.imul(al3, bh4) | 0;
    mid = mid + Math.imul(ah3, bl4) | 0;
    hi = hi + Math.imul(ah3, bh4) | 0;
    lo = lo + Math.imul(al2, bl5) | 0;
    mid = mid + Math.imul(al2, bh5) | 0;
    mid = mid + Math.imul(ah2, bl5) | 0;
    hi = hi + Math.imul(ah2, bh5) | 0;
    lo = lo + Math.imul(al1, bl6) | 0;
    mid = mid + Math.imul(al1, bh6) | 0;
    mid = mid + Math.imul(ah1, bl6) | 0;
    hi = hi + Math.imul(ah1, bh6) | 0;
    lo = lo + Math.imul(al0, bl7) | 0;
    mid = mid + Math.imul(al0, bh7) | 0;
    mid = mid + Math.imul(ah0, bl7) | 0;
    hi = hi + Math.imul(ah0, bh7) | 0;
    var w7 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
    w7 &= 0x3ffffff;
    /* k = 8 */

    lo = Math.imul(al8, bl0);
    mid = Math.imul(al8, bh0);
    mid = mid + Math.imul(ah8, bl0) | 0;
    hi = Math.imul(ah8, bh0);
    lo = lo + Math.imul(al7, bl1) | 0;
    mid = mid + Math.imul(al7, bh1) | 0;
    mid = mid + Math.imul(ah7, bl1) | 0;
    hi = hi + Math.imul(ah7, bh1) | 0;
    lo = lo + Math.imul(al6, bl2) | 0;
    mid = mid + Math.imul(al6, bh2) | 0;
    mid = mid + Math.imul(ah6, bl2) | 0;
    hi = hi + Math.imul(ah6, bh2) | 0;
    lo = lo + Math.imul(al5, bl3) | 0;
    mid = mid + Math.imul(al5, bh3) | 0;
    mid = mid + Math.imul(ah5, bl3) | 0;
    hi = hi + Math.imul(ah5, bh3) | 0;
    lo = lo + Math.imul(al4, bl4) | 0;
    mid = mid + Math.imul(al4, bh4) | 0;
    mid = mid + Math.imul(ah4, bl4) | 0;
    hi = hi + Math.imul(ah4, bh4) | 0;
    lo = lo + Math.imul(al3, bl5) | 0;
    mid = mid + Math.imul(al3, bh5) | 0;
    mid = mid + Math.imul(ah3, bl5) | 0;
    hi = hi + Math.imul(ah3, bh5) | 0;
    lo = lo + Math.imul(al2, bl6) | 0;
    mid = mid + Math.imul(al2, bh6) | 0;
    mid = mid + Math.imul(ah2, bl6) | 0;
    hi = hi + Math.imul(ah2, bh6) | 0;
    lo = lo + Math.imul(al1, bl7) | 0;
    mid = mid + Math.imul(al1, bh7) | 0;
    mid = mid + Math.imul(ah1, bl7) | 0;
    hi = hi + Math.imul(ah1, bh7) | 0;
    lo = lo + Math.imul(al0, bl8) | 0;
    mid = mid + Math.imul(al0, bh8) | 0;
    mid = mid + Math.imul(ah0, bl8) | 0;
    hi = hi + Math.imul(ah0, bh8) | 0;
    var w8 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
    w8 &= 0x3ffffff;
    /* k = 9 */

    lo = Math.imul(al9, bl0);
    mid = Math.imul(al9, bh0);
    mid = mid + Math.imul(ah9, bl0) | 0;
    hi = Math.imul(ah9, bh0);
    lo = lo + Math.imul(al8, bl1) | 0;
    mid = mid + Math.imul(al8, bh1) | 0;
    mid = mid + Math.imul(ah8, bl1) | 0;
    hi = hi + Math.imul(ah8, bh1) | 0;
    lo = lo + Math.imul(al7, bl2) | 0;
    mid = mid + Math.imul(al7, bh2) | 0;
    mid = mid + Math.imul(ah7, bl2) | 0;
    hi = hi + Math.imul(ah7, bh2) | 0;
    lo = lo + Math.imul(al6, bl3) | 0;
    mid = mid + Math.imul(al6, bh3) | 0;
    mid = mid + Math.imul(ah6, bl3) | 0;
    hi = hi + Math.imul(ah6, bh3) | 0;
    lo = lo + Math.imul(al5, bl4) | 0;
    mid = mid + Math.imul(al5, bh4) | 0;
    mid = mid + Math.imul(ah5, bl4) | 0;
    hi = hi + Math.imul(ah5, bh4) | 0;
    lo = lo + Math.imul(al4, bl5) | 0;
    mid = mid + Math.imul(al4, bh5) | 0;
    mid = mid + Math.imul(ah4, bl5) | 0;
    hi = hi + Math.imul(ah4, bh5) | 0;
    lo = lo + Math.imul(al3, bl6) | 0;
    mid = mid + Math.imul(al3, bh6) | 0;
    mid = mid + Math.imul(ah3, bl6) | 0;
    hi = hi + Math.imul(ah3, bh6) | 0;
    lo = lo + Math.imul(al2, bl7) | 0;
    mid = mid + Math.imul(al2, bh7) | 0;
    mid = mid + Math.imul(ah2, bl7) | 0;
    hi = hi + Math.imul(ah2, bh7) | 0;
    lo = lo + Math.imul(al1, bl8) | 0;
    mid = mid + Math.imul(al1, bh8) | 0;
    mid = mid + Math.imul(ah1, bl8) | 0;
    hi = hi + Math.imul(ah1, bh8) | 0;
    lo = lo + Math.imul(al0, bl9) | 0;
    mid = mid + Math.imul(al0, bh9) | 0;
    mid = mid + Math.imul(ah0, bl9) | 0;
    hi = hi + Math.imul(ah0, bh9) | 0;
    var w9 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
    w9 &= 0x3ffffff;
    /* k = 10 */

    lo = Math.imul(al9, bl1);
    mid = Math.imul(al9, bh1);
    mid = mid + Math.imul(ah9, bl1) | 0;
    hi = Math.imul(ah9, bh1);
    lo = lo + Math.imul(al8, bl2) | 0;
    mid = mid + Math.imul(al8, bh2) | 0;
    mid = mid + Math.imul(ah8, bl2) | 0;
    hi = hi + Math.imul(ah8, bh2) | 0;
    lo = lo + Math.imul(al7, bl3) | 0;
    mid = mid + Math.imul(al7, bh3) | 0;
    mid = mid + Math.imul(ah7, bl3) | 0;
    hi = hi + Math.imul(ah7, bh3) | 0;
    lo = lo + Math.imul(al6, bl4) | 0;
    mid = mid + Math.imul(al6, bh4) | 0;
    mid = mid + Math.imul(ah6, bl4) | 0;
    hi = hi + Math.imul(ah6, bh4) | 0;
    lo = lo + Math.imul(al5, bl5) | 0;
    mid = mid + Math.imul(al5, bh5) | 0;
    mid = mid + Math.imul(ah5, bl5) | 0;
    hi = hi + Math.imul(ah5, bh5) | 0;
    lo = lo + Math.imul(al4, bl6) | 0;
    mid = mid + Math.imul(al4, bh6) | 0;
    mid = mid + Math.imul(ah4, bl6) | 0;
    hi = hi + Math.imul(ah4, bh6) | 0;
    lo = lo + Math.imul(al3, bl7) | 0;
    mid = mid + Math.imul(al3, bh7) | 0;
    mid = mid + Math.imul(ah3, bl7) | 0;
    hi = hi + Math.imul(ah3, bh7) | 0;
    lo = lo + Math.imul(al2, bl8) | 0;
    mid = mid + Math.imul(al2, bh8) | 0;
    mid = mid + Math.imul(ah2, bl8) | 0;
    hi = hi + Math.imul(ah2, bh8) | 0;
    lo = lo + Math.imul(al1, bl9) | 0;
    mid = mid + Math.imul(al1, bh9) | 0;
    mid = mid + Math.imul(ah1, bl9) | 0;
    hi = hi + Math.imul(ah1, bh9) | 0;
    var w10 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
    w10 &= 0x3ffffff;
    /* k = 11 */

    lo = Math.imul(al9, bl2);
    mid = Math.imul(al9, bh2);
    mid = mid + Math.imul(ah9, bl2) | 0;
    hi = Math.imul(ah9, bh2);
    lo = lo + Math.imul(al8, bl3) | 0;
    mid = mid + Math.imul(al8, bh3) | 0;
    mid = mid + Math.imul(ah8, bl3) | 0;
    hi = hi + Math.imul(ah8, bh3) | 0;
    lo = lo + Math.imul(al7, bl4) | 0;
    mid = mid + Math.imul(al7, bh4) | 0;
    mid = mid + Math.imul(ah7, bl4) | 0;
    hi = hi + Math.imul(ah7, bh4) | 0;
    lo = lo + Math.imul(al6, bl5) | 0;
    mid = mid + Math.imul(al6, bh5) | 0;
    mid = mid + Math.imul(ah6, bl5) | 0;
    hi = hi + Math.imul(ah6, bh5) | 0;
    lo = lo + Math.imul(al5, bl6) | 0;
    mid = mid + Math.imul(al5, bh6) | 0;
    mid = mid + Math.imul(ah5, bl6) | 0;
    hi = hi + Math.imul(ah5, bh6) | 0;
    lo = lo + Math.imul(al4, bl7) | 0;
    mid = mid + Math.imul(al4, bh7) | 0;
    mid = mid + Math.imul(ah4, bl7) | 0;
    hi = hi + Math.imul(ah4, bh7) | 0;
    lo = lo + Math.imul(al3, bl8) | 0;
    mid = mid + Math.imul(al3, bh8) | 0;
    mid = mid + Math.imul(ah3, bl8) | 0;
    hi = hi + Math.imul(ah3, bh8) | 0;
    lo = lo + Math.imul(al2, bl9) | 0;
    mid = mid + Math.imul(al2, bh9) | 0;
    mid = mid + Math.imul(ah2, bl9) | 0;
    hi = hi + Math.imul(ah2, bh9) | 0;
    var w11 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
    w11 &= 0x3ffffff;
    /* k = 12 */

    lo = Math.imul(al9, bl3);
    mid = Math.imul(al9, bh3);
    mid = mid + Math.imul(ah9, bl3) | 0;
    hi = Math.imul(ah9, bh3);
    lo = lo + Math.imul(al8, bl4) | 0;
    mid = mid + Math.imul(al8, bh4) | 0;
    mid = mid + Math.imul(ah8, bl4) | 0;
    hi = hi + Math.imul(ah8, bh4) | 0;
    lo = lo + Math.imul(al7, bl5) | 0;
    mid = mid + Math.imul(al7, bh5) | 0;
    mid = mid + Math.imul(ah7, bl5) | 0;
    hi = hi + Math.imul(ah7, bh5) | 0;
    lo = lo + Math.imul(al6, bl6) | 0;
    mid = mid + Math.imul(al6, bh6) | 0;
    mid = mid + Math.imul(ah6, bl6) | 0;
    hi = hi + Math.imul(ah6, bh6) | 0;
    lo = lo + Math.imul(al5, bl7) | 0;
    mid = mid + Math.imul(al5, bh7) | 0;
    mid = mid + Math.imul(ah5, bl7) | 0;
    hi = hi + Math.imul(ah5, bh7) | 0;
    lo = lo + Math.imul(al4, bl8) | 0;
    mid = mid + Math.imul(al4, bh8) | 0;
    mid = mid + Math.imul(ah4, bl8) | 0;
    hi = hi + Math.imul(ah4, bh8) | 0;
    lo = lo + Math.imul(al3, bl9) | 0;
    mid = mid + Math.imul(al3, bh9) | 0;
    mid = mid + Math.imul(ah3, bl9) | 0;
    hi = hi + Math.imul(ah3, bh9) | 0;
    var w12 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
    w12 &= 0x3ffffff;
    /* k = 13 */

    lo = Math.imul(al9, bl4);
    mid = Math.imul(al9, bh4);
    mid = mid + Math.imul(ah9, bl4) | 0;
    hi = Math.imul(ah9, bh4);
    lo = lo + Math.imul(al8, bl5) | 0;
    mid = mid + Math.imul(al8, bh5) | 0;
    mid = mid + Math.imul(ah8, bl5) | 0;
    hi = hi + Math.imul(ah8, bh5) | 0;
    lo = lo + Math.imul(al7, bl6) | 0;
    mid = mid + Math.imul(al7, bh6) | 0;
    mid = mid + Math.imul(ah7, bl6) | 0;
    hi = hi + Math.imul(ah7, bh6) | 0;
    lo = lo + Math.imul(al6, bl7) | 0;
    mid = mid + Math.imul(al6, bh7) | 0;
    mid = mid + Math.imul(ah6, bl7) | 0;
    hi = hi + Math.imul(ah6, bh7) | 0;
    lo = lo + Math.imul(al5, bl8) | 0;
    mid = mid + Math.imul(al5, bh8) | 0;
    mid = mid + Math.imul(ah5, bl8) | 0;
    hi = hi + Math.imul(ah5, bh8) | 0;
    lo = lo + Math.imul(al4, bl9) | 0;
    mid = mid + Math.imul(al4, bh9) | 0;
    mid = mid + Math.imul(ah4, bl9) | 0;
    hi = hi + Math.imul(ah4, bh9) | 0;
    var w13 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
    w13 &= 0x3ffffff;
    /* k = 14 */

    lo = Math.imul(al9, bl5);
    mid = Math.imul(al9, bh5);
    mid = mid + Math.imul(ah9, bl5) | 0;
    hi = Math.imul(ah9, bh5);
    lo = lo + Math.imul(al8, bl6) | 0;
    mid = mid + Math.imul(al8, bh6) | 0;
    mid = mid + Math.imul(ah8, bl6) | 0;
    hi = hi + Math.imul(ah8, bh6) | 0;
    lo = lo + Math.imul(al7, bl7) | 0;
    mid = mid + Math.imul(al7, bh7) | 0;
    mid = mid + Math.imul(ah7, bl7) | 0;
    hi = hi + Math.imul(ah7, bh7) | 0;
    lo = lo + Math.imul(al6, bl8) | 0;
    mid = mid + Math.imul(al6, bh8) | 0;
    mid = mid + Math.imul(ah6, bl8) | 0;
    hi = hi + Math.imul(ah6, bh8) | 0;
    lo = lo + Math.imul(al5, bl9) | 0;
    mid = mid + Math.imul(al5, bh9) | 0;
    mid = mid + Math.imul(ah5, bl9) | 0;
    hi = hi + Math.imul(ah5, bh9) | 0;
    var w14 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
    w14 &= 0x3ffffff;
    /* k = 15 */

    lo = Math.imul(al9, bl6);
    mid = Math.imul(al9, bh6);
    mid = mid + Math.imul(ah9, bl6) | 0;
    hi = Math.imul(ah9, bh6);
    lo = lo + Math.imul(al8, bl7) | 0;
    mid = mid + Math.imul(al8, bh7) | 0;
    mid = mid + Math.imul(ah8, bl7) | 0;
    hi = hi + Math.imul(ah8, bh7) | 0;
    lo = lo + Math.imul(al7, bl8) | 0;
    mid = mid + Math.imul(al7, bh8) | 0;
    mid = mid + Math.imul(ah7, bl8) | 0;
    hi = hi + Math.imul(ah7, bh8) | 0;
    lo = lo + Math.imul(al6, bl9) | 0;
    mid = mid + Math.imul(al6, bh9) | 0;
    mid = mid + Math.imul(ah6, bl9) | 0;
    hi = hi + Math.imul(ah6, bh9) | 0;
    var w15 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
    w15 &= 0x3ffffff;
    /* k = 16 */

    lo = Math.imul(al9, bl7);
    mid = Math.imul(al9, bh7);
    mid = mid + Math.imul(ah9, bl7) | 0;
    hi = Math.imul(ah9, bh7);
    lo = lo + Math.imul(al8, bl8) | 0;
    mid = mid + Math.imul(al8, bh8) | 0;
    mid = mid + Math.imul(ah8, bl8) | 0;
    hi = hi + Math.imul(ah8, bh8) | 0;
    lo = lo + Math.imul(al7, bl9) | 0;
    mid = mid + Math.imul(al7, bh9) | 0;
    mid = mid + Math.imul(ah7, bl9) | 0;
    hi = hi + Math.imul(ah7, bh9) | 0;
    var w16 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
    w16 &= 0x3ffffff;
    /* k = 17 */

    lo = Math.imul(al9, bl8);
    mid = Math.imul(al9, bh8);
    mid = mid + Math.imul(ah9, bl8) | 0;
    hi = Math.imul(ah9, bh8);
    lo = lo + Math.imul(al8, bl9) | 0;
    mid = mid + Math.imul(al8, bh9) | 0;
    mid = mid + Math.imul(ah8, bl9) | 0;
    hi = hi + Math.imul(ah8, bh9) | 0;
    var w17 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
    w17 &= 0x3ffffff;
    /* k = 18 */

    lo = Math.imul(al9, bl9);
    mid = Math.imul(al9, bh9);
    mid = mid + Math.imul(ah9, bl9) | 0;
    hi = Math.imul(ah9, bh9);
    var w18 = (c + lo | 0) + ((mid & 0x1fff) << 13) | 0;
    c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
    w18 &= 0x3ffffff;
    o[0] = w0;
    o[1] = w1;
    o[2] = w2;
    o[3] = w3;
    o[4] = w4;
    o[5] = w5;
    o[6] = w6;
    o[7] = w7;
    o[8] = w8;
    o[9] = w9;
    o[10] = w10;
    o[11] = w11;
    o[12] = w12;
    o[13] = w13;
    o[14] = w14;
    o[15] = w15;
    o[16] = w16;
    o[17] = w17;
    o[18] = w18;

    if (c !== 0) {
      o[19] = c;
      out.length++;
    }

    return out;
  }; // Polyfill comb


  if (!Math.imul) {
    comb10MulTo = smallMulTo;
  }

  function bigMulTo(self, num, out) {
    out.negative = num.negative ^ self.negative;
    out.length = self.length + num.length;
    var carry = 0;
    var hncarry = 0;

    for (var k = 0; k < out.length - 1; k++) {
      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
      // note that ncarry could be >= 0x3ffffff
      var ncarry = hncarry;
      hncarry = 0;
      var rword = carry & 0x3ffffff;
      var maxJ = Math.min(k, num.length - 1);

      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
        var i = k - j;
        var a = self.words[i] | 0;
        var b = num.words[j] | 0;
        var r = a * b;
        var lo = r & 0x3ffffff;
        ncarry = ncarry + (r / 0x4000000 | 0) | 0;
        lo = lo + rword | 0;
        rword = lo & 0x3ffffff;
        ncarry = ncarry + (lo >>> 26) | 0;
        hncarry += ncarry >>> 26;
        ncarry &= 0x3ffffff;
      }

      out.words[k] = rword;
      carry = ncarry;
      ncarry = hncarry;
    }

    if (carry !== 0) {
      out.words[k] = carry;
    } else {
      out.length--;
    }

    return out.strip();
  }

  function jumboMulTo(self, num, out) {
    var fftm = new FFTM();
    return fftm.mulp(self, num, out);
  }

  BN.prototype.mulTo = function mulTo(num, out) {
    var res;
    var len = this.length + num.length;

    if (this.length === 10 && num.length === 10) {
      res = comb10MulTo(this, num, out);
    } else if (len < 63) {
      res = smallMulTo(this, num, out);
    } else if (len < 1024) {
      res = bigMulTo(this, num, out);
    } else {
      res = jumboMulTo(this, num, out);
    }

    return res;
  }; // Cooley-Tukey algorithm for FFT
  // slightly revisited to rely on looping instead of recursion


  function FFTM(x, y) {
    this.x = x;
    this.y = y;
  }

  FFTM.prototype.makeRBT = function makeRBT(N) {
    var t = new Array(N);
    var l = BN.prototype._countBits(N) - 1;

    for (var i = 0; i < N; i++) {
      t[i] = this.revBin(i, l, N);
    }

    return t;
  }; // Returns binary-reversed representation of `x`


  FFTM.prototype.revBin = function revBin(x, l, N) {
    if (x === 0 || x === N - 1) return x;
    var rb = 0;

    for (var i = 0; i < l; i++) {
      rb |= (x & 1) << l - i - 1;
      x >>= 1;
    }

    return rb;
  }; // Performs "tweedling" phase, therefore 'emulating'
  // behaviour of the recursive algorithm


  FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
    for (var i = 0; i < N; i++) {
      rtws[i] = rws[rbt[i]];
      itws[i] = iws[rbt[i]];
    }
  };

  FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
    this.permute(rbt, rws, iws, rtws, itws, N);

    for (var s = 1; s < N; s <<= 1) {
      var l = s << 1;
      var rtwdf = Math.cos(2 * Math.PI / l);
      var itwdf = Math.sin(2 * Math.PI / l);

      for (var p = 0; p < N; p += l) {
        var rtwdf_ = rtwdf;
        var itwdf_ = itwdf;

        for (var j = 0; j < s; j++) {
          var re = rtws[p + j];
          var ie = itws[p + j];
          var ro = rtws[p + j + s];
          var io = itws[p + j + s];
          var rx = rtwdf_ * ro - itwdf_ * io;
          io = rtwdf_ * io + itwdf_ * ro;
          ro = rx;
          rtws[p + j] = re + ro;
          itws[p + j] = ie + io;
          rtws[p + j + s] = re - ro;
          itws[p + j + s] = ie - io;
          /* jshint maxdepth : false */

          if (j !== l) {
            rx = rtwdf * rtwdf_ - itwdf * itwdf_;
            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
            rtwdf_ = rx;
          }
        }
      }
    }
  };

  FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
    var N = Math.max(m, n) | 1;
    var odd = N & 1;
    var i = 0;

    for (N = N / 2 | 0; N; N = N >>> 1) {
      i++;
    }

    return 1 << i + 1 + odd;
  };

  FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
    if (N <= 1) return;

    for (var i = 0; i < N / 2; i++) {
      var t = rws[i];
      rws[i] = rws[N - i - 1];
      rws[N - i - 1] = t;
      t = iws[i];
      iws[i] = -iws[N - i - 1];
      iws[N - i - 1] = -t;
    }
  };

  FFTM.prototype.normalize13b = function normalize13b(ws, N) {
    var carry = 0;

    for (var i = 0; i < N / 2; i++) {
      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 + Math.round(ws[2 * i] / N) + carry;
      ws[i] = w & 0x3ffffff;

      if (w < 0x4000000) {
        carry = 0;
      } else {
        carry = w / 0x4000000 | 0;
      }
    }

    return ws;
  };

  FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
    var carry = 0;

    for (var i = 0; i < len; i++) {
      carry = carry + (ws[i] | 0);
      rws[2 * i] = carry & 0x1fff;
      carry = carry >>> 13;
      rws[2 * i + 1] = carry & 0x1fff;
      carry = carry >>> 13;
    } // Pad with zeroes


    for (i = 2 * len; i < N; ++i) {
      rws[i] = 0;
    }

    assert(carry === 0);
    assert((carry & ~0x1fff) === 0);
  };

  FFTM.prototype.stub = function stub(N) {
    var ph = new Array(N);

    for (var i = 0; i < N; i++) {
      ph[i] = 0;
    }

    return ph;
  };

  FFTM.prototype.mulp = function mulp(x, y, out) {
    var N = 2 * this.guessLen13b(x.length, y.length);
    var rbt = this.makeRBT(N);

    var _ = this.stub(N);

    var rws = new Array(N);
    var rwst = new Array(N);
    var iwst = new Array(N);
    var nrws = new Array(N);
    var nrwst = new Array(N);
    var niwst = new Array(N);
    var rmws = out.words;
    rmws.length = N;
    this.convert13b(x.words, x.length, rws, N);
    this.convert13b(y.words, y.length, nrws, N);
    this.transform(rws, _, rwst, iwst, N, rbt);
    this.transform(nrws, _, nrwst, niwst, N, rbt);

    for (var i = 0; i < N; i++) {
      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
      rwst[i] = rx;
    }

    this.conjugate(rwst, iwst, N);
    this.transform(rwst, iwst, rmws, _, N, rbt);
    this.conjugate(rmws, _, N);
    this.normalize13b(rmws, N);
    out.negative = x.negative ^ y.negative;
    out.length = x.length + y.length;
    return out.strip();
  }; // Multiply `this` by `num`


  BN.prototype.mul = function mul(num) {
    var out = new BN(null);
    out.words = new Array(this.length + num.length);
    return this.mulTo(num, out);
  }; // Multiply employing FFT


  BN.prototype.mulf = function mulf(num) {
    var out = new BN(null);
    out.words = new Array(this.length + num.length);
    return jumboMulTo(this, num, out);
  }; // In-place Multiplication


  BN.prototype.imul = function imul(num) {
    return this.clone().mulTo(num, this);
  };

  BN.prototype.imuln = function imuln(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000); // Carry

    var carry = 0;

    for (var i = 0; i < this.length; i++) {
      var w = (this.words[i] | 0) * num;
      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
      carry >>= 26;
      carry += w / 0x4000000 | 0; // NOTE: lo is 27bit maximum

      carry += lo >>> 26;
      this.words[i] = lo & 0x3ffffff;
    }

    if (carry !== 0) {
      this.words[i] = carry;
      this.length++;
    }

    return this;
  };

  BN.prototype.muln = function muln(num) {
    return this.clone().imuln(num);
  }; // `this` * `this`


  BN.prototype.sqr = function sqr() {
    return this.mul(this);
  }; // `this` * `this` in-place


  BN.prototype.isqr = function isqr() {
    return this.imul(this.clone());
  }; // Math.pow(`this`, `num`)


  BN.prototype.pow = function pow(num) {
    var w = toBitArray(num);
    if (w.length === 0) return new BN(1); // Skip leading zeroes

    var res = this;

    for (var i = 0; i < w.length; i++, res = res.sqr()) {
      if (w[i] !== 0) break;
    }

    if (++i < w.length) {
      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
        if (w[i] === 0) continue;
        res = res.mul(q);
      }
    }

    return res;
  }; // Shift-left in-place


  BN.prototype.iushln = function iushln(bits) {
    assert(typeof bits === 'number' && bits >= 0);
    var r = bits % 26;
    var s = (bits - r) / 26;
    var carryMask = 0x3ffffff >>> 26 - r << 26 - r;
    var i;

    if (r !== 0) {
      var carry = 0;

      for (i = 0; i < this.length; i++) {
        var newCarry = this.words[i] & carryMask;
        var c = (this.words[i] | 0) - newCarry << r;
        this.words[i] = c | carry;
        carry = newCarry >>> 26 - r;
      }

      if (carry) {
        this.words[i] = carry;
        this.length++;
      }
    }

    if (s !== 0) {
      for (i = this.length - 1; i >= 0; i--) {
        this.words[i + s] = this.words[i];
      }

      for (i = 0; i < s; i++) {
        this.words[i] = 0;
      }

      this.length += s;
    }

    return this.strip();
  };

  BN.prototype.ishln = function ishln(bits) {
    // TODO(indutny): implement me
    assert(this.negative === 0);
    return this.iushln(bits);
  }; // Shift-right in-place
  // NOTE: `hint` is a lowest bit before trailing zeroes
  // NOTE: if `extended` is present - it will be filled with destroyed bits


  BN.prototype.iushrn = function iushrn(bits, hint, extended) {
    assert(typeof bits === 'number' && bits >= 0);
    var h;

    if (hint) {
      h = (hint - hint % 26) / 26;
    } else {
      h = 0;
    }

    var r = bits % 26;
    var s = Math.min((bits - r) / 26, this.length);
    var mask = 0x3ffffff ^ 0x3ffffff >>> r << r;
    var maskedWords = extended;
    h -= s;
    h = Math.max(0, h); // Extended mode, copy masked part

    if (maskedWords) {
      for (var i = 0; i < s; i++) {
        maskedWords.words[i] = this.words[i];
      }

      maskedWords.length = s;
    }

    if (s === 0) {// No-op, we should not move anything at all
    } else if (this.length > s) {
      this.length -= s;

      for (i = 0; i < this.length; i++) {
        this.words[i] = this.words[i + s];
      }
    } else {
      this.words[0] = 0;
      this.length = 1;
    }

    var carry = 0;

    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
      var word = this.words[i] | 0;
      this.words[i] = carry << 26 - r | word >>> r;
      carry = word & mask;
    } // Push carried bits as a mask


    if (maskedWords && carry !== 0) {
      maskedWords.words[maskedWords.length++] = carry;
    }

    if (this.length === 0) {
      this.words[0] = 0;
      this.length = 1;
    }

    return this.strip();
  };

  BN.prototype.ishrn = function ishrn(bits, hint, extended) {
    // TODO(indutny): implement me
    assert(this.negative === 0);
    return this.iushrn(bits, hint, extended);
  }; // Shift-left


  BN.prototype.shln = function shln(bits) {
    return this.clone().ishln(bits);
  };

  BN.prototype.ushln = function ushln(bits) {
    return this.clone().iushln(bits);
  }; // Shift-right


  BN.prototype.shrn = function shrn(bits) {
    return this.clone().ishrn(bits);
  };

  BN.prototype.ushrn = function ushrn(bits) {
    return this.clone().iushrn(bits);
  }; // Test if n bit is set


  BN.prototype.testn = function testn(bit) {
    assert(typeof bit === 'number' && bit >= 0);
    var r = bit % 26;
    var s = (bit - r) / 26;
    var q = 1 << r; // Fast case: bit is much higher than all existing words

    if (this.length <= s) return false; // Check bit and return

    var w = this.words[s];
    return !!(w & q);
  }; // Return only lowers bits of number (in-place)


  BN.prototype.imaskn = function imaskn(bits) {
    assert(typeof bits === 'number' && bits >= 0);
    var r = bits % 26;
    var s = (bits - r) / 26;
    assert(this.negative === 0, 'imaskn works only with positive numbers');

    if (this.length <= s) {
      return this;
    }

    if (r !== 0) {
      s++;
    }

    this.length = Math.min(s, this.length);

    if (r !== 0) {
      var mask = 0x3ffffff ^ 0x3ffffff >>> r << r;
      this.words[this.length - 1] &= mask;
    }

    return this.strip();
  }; // Return only lowers bits of number


  BN.prototype.maskn = function maskn(bits) {
    return this.clone().imaskn(bits);
  }; // Add plain number `num` to `this`


  BN.prototype.iaddn = function iaddn(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000);
    if (num < 0) return this.isubn(-num); // Possible sign change

    if (this.negative !== 0) {
      if (this.length === 1 && (this.words[0] | 0) < num) {
        this.words[0] = num - (this.words[0] | 0);
        this.negative = 0;
        return this;
      }

      this.negative = 0;
      this.isubn(num);
      this.negative = 1;
      return this;
    } // Add without checks


    return this._iaddn(num);
  };

  BN.prototype._iaddn = function _iaddn(num) {
    this.words[0] += num; // Carry

    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
      this.words[i] -= 0x4000000;

      if (i === this.length - 1) {
        this.words[i + 1] = 1;
      } else {
        this.words[i + 1]++;
      }
    }

    this.length = Math.max(this.length, i + 1);
    return this;
  }; // Subtract plain number `num` from `this`


  BN.prototype.isubn = function isubn(num) {
    assert(typeof num === 'number');
    assert(num < 0x4000000);
    if (num < 0) return this.iaddn(-num);

    if (this.negative !== 0) {
      this.negative = 0;
      this.iaddn(num);
      this.negative = 1;
      return this;
    }

    this.words[0] -= num;

    if (this.length === 1 && this.words[0] < 0) {
      this.words[0] = -this.words[0];
      this.negative = 1;
    } else {
      // Carry
      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
        this.words[i] += 0x4000000;
        this.words[i + 1] -= 1;
      }
    }

    return this.strip();
  };

  BN.prototype.addn = function addn(num) {
    return this.clone().iaddn(num);
  };

  BN.prototype.subn = function subn(num) {
    return this.clone().isubn(num);
  };

  BN.prototype.iabs = function iabs() {
    this.negative = 0;
    return this;
  };

  BN.prototype.abs = function abs() {
    return this.clone().iabs();
  };

  BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
    var len = num.length + shift;
    var i;

    this._expand(len);

    var w;
    var carry = 0;

    for (i = 0; i < num.length; i++) {
      w = (this.words[i + shift] | 0) + carry;
      var right = (num.words[i] | 0) * mul;
      w -= right & 0x3ffffff;
      carry = (w >> 26) - (right / 0x4000000 | 0);
      this.words[i + shift] = w & 0x3ffffff;
    }

    for (; i < this.length - shift; i++) {
      w = (this.words[i + shift] | 0) + carry;
      carry = w >> 26;
      this.words[i + shift] = w & 0x3ffffff;
    }

    if (carry === 0) return this.strip(); // Subtraction overflow

    assert(carry === -1);
    carry = 0;

    for (i = 0; i < this.length; i++) {
      w = -(this.words[i] | 0) + carry;
      carry = w >> 26;
      this.words[i] = w & 0x3ffffff;
    }

    this.negative = 1;
    return this.strip();
  };

  BN.prototype._wordDiv = function _wordDiv(num, mode) {
    var shift = this.length - num.length;
    var a = this.clone();
    var b = num; // Normalize

    var bhi = b.words[b.length - 1] | 0;

    var bhiBits = this._countBits(bhi);

    shift = 26 - bhiBits;

    if (shift !== 0) {
      b = b.ushln(shift);
      a.iushln(shift);
      bhi = b.words[b.length - 1] | 0;
    } // Initialize quotient


    var m = a.length - b.length;
    var q;

    if (mode !== 'mod') {
      q = new BN(null);
      q.length = m + 1;
      q.words = new Array(q.length);

      for (var i = 0; i < q.length; i++) {
        q.words[i] = 0;
      }
    }

    var diff = a.clone()._ishlnsubmul(b, 1, m);

    if (diff.negative === 0) {
      a = diff;

      if (q) {
        q.words[m] = 1;
      }
    }

    for (var j = m - 1; j >= 0; j--) {
      var qj = (a.words[b.length + j] | 0) * 0x4000000 + (a.words[b.length + j - 1] | 0); // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
      // (0x7ffffff)

      qj = Math.min(qj / bhi | 0, 0x3ffffff);

      a._ishlnsubmul(b, qj, j);

      while (a.negative !== 0) {
        qj--;
        a.negative = 0;

        a._ishlnsubmul(b, 1, j);

        if (!a.isZero()) {
          a.negative ^= 1;
        }
      }

      if (q) {
        q.words[j] = qj;
      }
    }

    if (q) {
      q.strip();
    }

    a.strip(); // Denormalize

    if (mode !== 'div' && shift !== 0) {
      a.iushrn(shift);
    }

    return {
      div: q || null,
      mod: a
    };
  }; // NOTE: 1) `mode` can be set to `mod` to request mod only,
  //       to `div` to request div only, or be absent to
  //       request both div & mod
  //       2) `positive` is true if unsigned mod is requested


  BN.prototype.divmod = function divmod(num, mode, positive) {
    assert(!num.isZero());

    if (this.isZero()) {
      return {
        div: new BN(0),
        mod: new BN(0)
      };
    }

    var div, mod, res;

    if (this.negative !== 0 && num.negative === 0) {
      res = this.neg().divmod(num, mode);

      if (mode !== 'mod') {
        div = res.div.neg();
      }

      if (mode !== 'div') {
        mod = res.mod.neg();

        if (positive && mod.negative !== 0) {
          mod.iadd(num);
        }
      }

      return {
        div: div,
        mod: mod
      };
    }

    if (this.negative === 0 && num.negative !== 0) {
      res = this.divmod(num.neg(), mode);

      if (mode !== 'mod') {
        div = res.div.neg();
      }

      return {
        div: div,
        mod: res.mod
      };
    }

    if ((this.negative & num.negative) !== 0) {
      res = this.neg().divmod(num.neg(), mode);

      if (mode !== 'div') {
        mod = res.mod.neg();

        if (positive && mod.negative !== 0) {
          mod.isub(num);
        }
      }

      return {
        div: res.div,
        mod: mod
      };
    } // Both numbers are positive at this point
    // Strip both numbers to approximate shift value


    if (num.length > this.length || this.cmp(num) < 0) {
      return {
        div: new BN(0),
        mod: this
      };
    } // Very short reduction


    if (num.length === 1) {
      if (mode === 'div') {
        return {
          div: this.divn(num.words[0]),
          mod: null
        };
      }

      if (mode === 'mod') {
        return {
          div: null,
          mod: new BN(this.modn(num.words[0]))
        };
      }

      return {
        div: this.divn(num.words[0]),
        mod: new BN(this.modn(num.words[0]))
      };
    }

    return this._wordDiv(num, mode);
  }; // Find `this` / `num`


  BN.prototype.div = function div(num) {
    return this.divmod(num, 'div', false).div;
  }; // Find `this` % `num`


  BN.prototype.mod = function mod(num) {
    return this.divmod(num, 'mod', false).mod;
  };

  BN.prototype.umod = function umod(num) {
    return this.divmod(num, 'mod', true).mod;
  }; // Find Round(`this` / `num`)


  BN.prototype.divRound = function divRound(num) {
    var dm = this.divmod(num); // Fast case - exact division

    if (dm.mod.isZero()) return dm.div;
    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
    var half = num.ushrn(1);
    var r2 = num.andln(1);
    var cmp = mod.cmp(half); // Round down

    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div; // Round up

    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
  };

  BN.prototype.modn = function modn(num) {
    assert(num <= 0x3ffffff);
    var p = (1 << 26) % num;
    var acc = 0;

    for (var i = this.length - 1; i >= 0; i--) {
      acc = (p * acc + (this.words[i] | 0)) % num;
    }

    return acc;
  }; // In-place division by number


  BN.prototype.idivn = function idivn(num) {
    assert(num <= 0x3ffffff);
    var carry = 0;

    for (var i = this.length - 1; i >= 0; i--) {
      var w = (this.words[i] | 0) + carry * 0x4000000;
      this.words[i] = w / num | 0;
      carry = w % num;
    }

    return this.strip();
  };

  BN.prototype.divn = function divn(num) {
    return this.clone().idivn(num);
  };

  BN.prototype.egcd = function egcd(p) {
    assert(p.negative === 0);
    assert(!p.isZero());
    var x = this;
    var y = p.clone();

    if (x.negative !== 0) {
      x = x.umod(p);
    } else {
      x = x.clone();
    } // A * x + B * y = x


    var A = new BN(1);
    var B = new BN(0); // C * x + D * y = y

    var C = new BN(0);
    var D = new BN(1);
    var g = 0;

    while (x.isEven() && y.isEven()) {
      x.iushrn(1);
      y.iushrn(1);
      ++g;
    }

    var yp = y.clone();
    var xp = x.clone();

    while (!x.isZero()) {
      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1) {
        ;
      }

      if (i > 0) {
        x.iushrn(i);

        while (i-- > 0) {
          if (A.isOdd() || B.isOdd()) {
            A.iadd(yp);
            B.isub(xp);
          }

          A.iushrn(1);
          B.iushrn(1);
        }
      }

      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) {
        ;
      }

      if (j > 0) {
        y.iushrn(j);

        while (j-- > 0) {
          if (C.isOdd() || D.isOdd()) {
            C.iadd(yp);
            D.isub(xp);
          }

          C.iushrn(1);
          D.iushrn(1);
        }
      }

      if (x.cmp(y) >= 0) {
        x.isub(y);
        A.isub(C);
        B.isub(D);
      } else {
        y.isub(x);
        C.isub(A);
        D.isub(B);
      }
    }

    return {
      a: C,
      b: D,
      gcd: y.iushln(g)
    };
  }; // This is reduced incarnation of the binary EEA
  // above, designated to invert members of the
  // _prime_ fields F(p) at a maximal speed


  BN.prototype._invmp = function _invmp(p) {
    assert(p.negative === 0);
    assert(!p.isZero());
    var a = this;
    var b = p.clone();

    if (a.negative !== 0) {
      a = a.umod(p);
    } else {
      a = a.clone();
    }

    var x1 = new BN(1);
    var x2 = new BN(0);
    var delta = b.clone();

    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1) {
        ;
      }

      if (i > 0) {
        a.iushrn(i);

        while (i-- > 0) {
          if (x1.isOdd()) {
            x1.iadd(delta);
          }

          x1.iushrn(1);
        }
      }

      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) {
        ;
      }

      if (j > 0) {
        b.iushrn(j);

        while (j-- > 0) {
          if (x2.isOdd()) {
            x2.iadd(delta);
          }

          x2.iushrn(1);
        }
      }

      if (a.cmp(b) >= 0) {
        a.isub(b);
        x1.isub(x2);
      } else {
        b.isub(a);
        x2.isub(x1);
      }
    }

    var res;

    if (a.cmpn(1) === 0) {
      res = x1;
    } else {
      res = x2;
    }

    if (res.cmpn(0) < 0) {
      res.iadd(p);
    }

    return res;
  };

  BN.prototype.gcd = function gcd(num) {
    if (this.isZero()) return num.abs();
    if (num.isZero()) return this.abs();
    var a = this.clone();
    var b = num.clone();
    a.negative = 0;
    b.negative = 0; // Remove common factor of two

    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
      a.iushrn(1);
      b.iushrn(1);
    }

    do {
      while (a.isEven()) {
        a.iushrn(1);
      }

      while (b.isEven()) {
        b.iushrn(1);
      }

      var r = a.cmp(b);

      if (r < 0) {
        // Swap `a` and `b` to make `a` always bigger than `b`
        var t = a;
        a = b;
        b = t;
      } else if (r === 0 || b.cmpn(1) === 0) {
        break;
      }

      a.isub(b);
    } while (true);

    return b.iushln(shift);
  }; // Invert number in the field F(num)


  BN.prototype.invm = function invm(num) {
    return this.egcd(num).a.umod(num);
  };

  BN.prototype.isEven = function isEven() {
    return (this.words[0] & 1) === 0;
  };

  BN.prototype.isOdd = function isOdd() {
    return (this.words[0] & 1) === 1;
  }; // And first word and num


  BN.prototype.andln = function andln(num) {
    return this.words[0] & num;
  }; // Increment at the bit position in-line


  BN.prototype.bincn = function bincn(bit) {
    assert(typeof bit === 'number');
    var r = bit % 26;
    var s = (bit - r) / 26;
    var q = 1 << r; // Fast case: bit is much higher than all existing words

    if (this.length <= s) {
      this._expand(s + 1);

      this.words[s] |= q;
      return this;
    } // Add bit and propagate, if needed


    var carry = q;

    for (var i = s; carry !== 0 && i < this.length; i++) {
      var w = this.words[i] | 0;
      w += carry;
      carry = w >>> 26;
      w &= 0x3ffffff;
      this.words[i] = w;
    }

    if (carry !== 0) {
      this.words[i] = carry;
      this.length++;
    }

    return this;
  };

  BN.prototype.isZero = function isZero() {
    return this.length === 1 && this.words[0] === 0;
  };

  BN.prototype.cmpn = function cmpn(num) {
    var negative = num < 0;
    if (this.negative !== 0 && !negative) return -1;
    if (this.negative === 0 && negative) return 1;
    this.strip();
    var res;

    if (this.length > 1) {
      res = 1;
    } else {
      if (negative) {
        num = -num;
      }

      assert(num <= 0x3ffffff, 'Number is too big');
      var w = this.words[0] | 0;
      res = w === num ? 0 : w < num ? -1 : 1;
    }

    if (this.negative !== 0) return -res | 0;
    return res;
  }; // Compare two numbers and return:
  // 1 - if `this` > `num`
  // 0 - if `this` == `num`
  // -1 - if `this` < `num`


  BN.prototype.cmp = function cmp(num) {
    if (this.negative !== 0 && num.negative === 0) return -1;
    if (this.negative === 0 && num.negative !== 0) return 1;
    var res = this.ucmp(num);
    if (this.negative !== 0) return -res | 0;
    return res;
  }; // Unsigned comparison


  BN.prototype.ucmp = function ucmp(num) {
    // At this point both numbers have the same sign
    if (this.length > num.length) return 1;
    if (this.length < num.length) return -1;
    var res = 0;

    for (var i = this.length - 1; i >= 0; i--) {
      var a = this.words[i] | 0;
      var b = num.words[i] | 0;
      if (a === b) continue;

      if (a < b) {
        res = -1;
      } else if (a > b) {
        res = 1;
      }

      break;
    }

    return res;
  };

  BN.prototype.gtn = function gtn(num) {
    return this.cmpn(num) === 1;
  };

  BN.prototype.gt = function gt(num) {
    return this.cmp(num) === 1;
  };

  BN.prototype.gten = function gten(num) {
    return this.cmpn(num) >= 0;
  };

  BN.prototype.gte = function gte(num) {
    return this.cmp(num) >= 0;
  };

  BN.prototype.ltn = function ltn(num) {
    return this.cmpn(num) === -1;
  };

  BN.prototype.lt = function lt(num) {
    return this.cmp(num) === -1;
  };

  BN.prototype.lten = function lten(num) {
    return this.cmpn(num) <= 0;
  };

  BN.prototype.lte = function lte(num) {
    return this.cmp(num) <= 0;
  };

  BN.prototype.eqn = function eqn(num) {
    return this.cmpn(num) === 0;
  };

  BN.prototype.eq = function eq(num) {
    return this.cmp(num) === 0;
  }; //
  // A reduce context, could be using montgomery or something better, depending
  // on the `m` itself.
  //


  BN.red = function red(num) {
    return new Red(num);
  };

  BN.prototype.toRed = function toRed(ctx) {
    assert(!this.red, 'Already a number in reduction context');
    assert(this.negative === 0, 'red works only with positives');
    return ctx.convertTo(this)._forceRed(ctx);
  };

  BN.prototype.fromRed = function fromRed() {
    assert(this.red, 'fromRed works only with numbers in reduction context');
    return this.red.convertFrom(this);
  };

  BN.prototype._forceRed = function _forceRed(ctx) {
    this.red = ctx;
    return this;
  };

  BN.prototype.forceRed = function forceRed(ctx) {
    assert(!this.red, 'Already a number in reduction context');
    return this._forceRed(ctx);
  };

  BN.prototype.redAdd = function redAdd(num) {
    assert(this.red, 'redAdd works only with red numbers');
    return this.red.add(this, num);
  };

  BN.prototype.redIAdd = function redIAdd(num) {
    assert(this.red, 'redIAdd works only with red numbers');
    return this.red.iadd(this, num);
  };

  BN.prototype.redSub = function redSub(num) {
    assert(this.red, 'redSub works only with red numbers');
    return this.red.sub(this, num);
  };

  BN.prototype.redISub = function redISub(num) {
    assert(this.red, 'redISub works only with red numbers');
    return this.red.isub(this, num);
  };

  BN.prototype.redShl = function redShl(num) {
    assert(this.red, 'redShl works only with red numbers');
    return this.red.shl(this, num);
  };

  BN.prototype.redMul = function redMul(num) {
    assert(this.red, 'redMul works only with red numbers');

    this.red._verify2(this, num);

    return this.red.mul(this, num);
  };

  BN.prototype.redIMul = function redIMul(num) {
    assert(this.red, 'redMul works only with red numbers');

    this.red._verify2(this, num);

    return this.red.imul(this, num);
  };

  BN.prototype.redSqr = function redSqr() {
    assert(this.red, 'redSqr works only with red numbers');

    this.red._verify1(this);

    return this.red.sqr(this);
  };

  BN.prototype.redISqr = function redISqr() {
    assert(this.red, 'redISqr works only with red numbers');

    this.red._verify1(this);

    return this.red.isqr(this);
  }; // Square root over p


  BN.prototype.redSqrt = function redSqrt() {
    assert(this.red, 'redSqrt works only with red numbers');

    this.red._verify1(this);

    return this.red.sqrt(this);
  };

  BN.prototype.redInvm = function redInvm() {
    assert(this.red, 'redInvm works only with red numbers');

    this.red._verify1(this);

    return this.red.invm(this);
  }; // Return negative clone of `this` % `red modulo`


  BN.prototype.redNeg = function redNeg() {
    assert(this.red, 'redNeg works only with red numbers');

    this.red._verify1(this);

    return this.red.neg(this);
  };

  BN.prototype.redPow = function redPow(num) {
    assert(this.red && !num.red, 'redPow(normalNum)');

    this.red._verify1(this);

    return this.red.pow(this, num);
  }; // Prime numbers with efficient reduction


  var primes = {
    k256: null,
    p224: null,
    p192: null,
    p25519: null
  }; // Pseudo-Mersenne prime

  function MPrime(name, p) {
    // P = 2 ^ N - K
    this.name = name;
    this.p = new BN(p, 16);
    this.n = this.p.bitLength();
    this.k = new BN(1).iushln(this.n).isub(this.p);
    this.tmp = this._tmp();
  }

  MPrime.prototype._tmp = function _tmp() {
    var tmp = new BN(null);
    tmp.words = new Array(Math.ceil(this.n / 13));
    return tmp;
  };

  MPrime.prototype.ireduce = function ireduce(num) {
    // Assumes that `num` is less than `P^2`
    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)
    var r = num;
    var rlen;

    do {
      this.split(r, this.tmp);
      r = this.imulK(r);
      r = r.iadd(this.tmp);
      rlen = r.bitLength();
    } while (rlen > this.n);

    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);

    if (cmp === 0) {
      r.words[0] = 0;
      r.length = 1;
    } else if (cmp > 0) {
      r.isub(this.p);
    } else {
      r.strip();
    }

    return r;
  };

  MPrime.prototype.split = function split(input, out) {
    input.iushrn(this.n, 0, out);
  };

  MPrime.prototype.imulK = function imulK(num) {
    return num.imul(this.k);
  };

  function K256() {
    MPrime.call(this, 'k256', 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');
  }

  inherits(K256, MPrime);

  K256.prototype.split = function split(input, output) {
    // 256 = 9 * 26 + 22
    var mask = 0x3fffff;
    var outLen = Math.min(input.length, 9);

    for (var i = 0; i < outLen; i++) {
      output.words[i] = input.words[i];
    }

    output.length = outLen;

    if (input.length <= 9) {
      input.words[0] = 0;
      input.length = 1;
      return;
    } // Shift by 9 limbs


    var prev = input.words[9];
    output.words[output.length++] = prev & mask;

    for (i = 10; i < input.length; i++) {
      var next = input.words[i] | 0;
      input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
      prev = next;
    }

    prev >>>= 22;
    input.words[i - 10] = prev;

    if (prev === 0 && input.length > 10) {
      input.length -= 10;
    } else {
      input.length -= 9;
    }
  };

  K256.prototype.imulK = function imulK(num) {
    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]
    num.words[num.length] = 0;
    num.words[num.length + 1] = 0;
    num.length += 2; // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390

    var lo = 0;

    for (var i = 0; i < num.length; i++) {
      var w = num.words[i] | 0;
      lo += w * 0x3d1;
      num.words[i] = lo & 0x3ffffff;
      lo = w * 0x40 + (lo / 0x4000000 | 0);
    } // Fast length reduction


    if (num.words[num.length - 1] === 0) {
      num.length--;

      if (num.words[num.length - 1] === 0) {
        num.length--;
      }
    }

    return num;
  };

  function P224() {
    MPrime.call(this, 'p224', 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');
  }

  inherits(P224, MPrime);

  function P192() {
    MPrime.call(this, 'p192', 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');
  }

  inherits(P192, MPrime);

  function P25519() {
    // 2 ^ 255 - 19
    MPrime.call(this, '25519', '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');
  }

  inherits(P25519, MPrime);

  P25519.prototype.imulK = function imulK(num) {
    // K = 0x13
    var carry = 0;

    for (var i = 0; i < num.length; i++) {
      var hi = (num.words[i] | 0) * 0x13 + carry;
      var lo = hi & 0x3ffffff;
      hi >>>= 26;
      num.words[i] = lo;
      carry = hi;
    }

    if (carry !== 0) {
      num.words[num.length++] = carry;
    }

    return num;
  }; // Exported mostly for testing purposes, use plain name instead


  BN._prime = function prime(name) {
    // Cached version of prime
    if (primes[name]) return primes[name];
    var prime;

    if (name === 'k256') {
      prime = new K256();
    } else if (name === 'p224') {
      prime = new P224();
    } else if (name === 'p192') {
      prime = new P192();
    } else if (name === 'p25519') {
      prime = new P25519();
    } else {
      throw new Error('Unknown prime ' + name);
    }

    primes[name] = prime;
    return prime;
  }; //
  // Base reduction engine
  //


  function Red(m) {
    if (typeof m === 'string') {
      var prime = BN._prime(m);

      this.m = prime.p;
      this.prime = prime;
    } else {
      assert(m.gtn(1), 'modulus must be greater than 1');
      this.m = m;
      this.prime = null;
    }
  }

  Red.prototype._verify1 = function _verify1(a) {
    assert(a.negative === 0, 'red works only with positives');
    assert(a.red, 'red works only with red numbers');
  };

  Red.prototype._verify2 = function _verify2(a, b) {
    assert((a.negative | b.negative) === 0, 'red works only with positives');
    assert(a.red && a.red === b.red, 'red works only with red numbers');
  };

  Red.prototype.imod = function imod(a) {
    if (this.prime) return this.prime.ireduce(a)._forceRed(this);
    return a.umod(this.m)._forceRed(this);
  };

  Red.prototype.neg = function neg(a) {
    if (a.isZero()) {
      return a.clone();
    }

    return this.m.sub(a)._forceRed(this);
  };

  Red.prototype.add = function add(a, b) {
    this._verify2(a, b);

    var res = a.add(b);

    if (res.cmp(this.m) >= 0) {
      res.isub(this.m);
    }

    return res._forceRed(this);
  };

  Red.prototype.iadd = function iadd(a, b) {
    this._verify2(a, b);

    var res = a.iadd(b);

    if (res.cmp(this.m) >= 0) {
      res.isub(this.m);
    }

    return res;
  };

  Red.prototype.sub = function sub(a, b) {
    this._verify2(a, b);

    var res = a.sub(b);

    if (res.cmpn(0) < 0) {
      res.iadd(this.m);
    }

    return res._forceRed(this);
  };

  Red.prototype.isub = function isub(a, b) {
    this._verify2(a, b);

    var res = a.isub(b);

    if (res.cmpn(0) < 0) {
      res.iadd(this.m);
    }

    return res;
  };

  Red.prototype.shl = function shl(a, num) {
    this._verify1(a);

    return this.imod(a.ushln(num));
  };

  Red.prototype.imul = function imul(a, b) {
    this._verify2(a, b);

    return this.imod(a.imul(b));
  };

  Red.prototype.mul = function mul(a, b) {
    this._verify2(a, b);

    return this.imod(a.mul(b));
  };

  Red.prototype.isqr = function isqr(a) {
    return this.imul(a, a.clone());
  };

  Red.prototype.sqr = function sqr(a) {
    return this.mul(a, a);
  };

  Red.prototype.sqrt = function sqrt(a) {
    if (a.isZero()) return a.clone();
    var mod3 = this.m.andln(3);
    assert(mod3 % 2 === 1); // Fast case

    if (mod3 === 3) {
      var pow = this.m.add(new BN(1)).iushrn(2);
      return this.pow(a, pow);
    } // Tonelli-Shanks algorithm (Totally unoptimized and slow)
    //
    // Find Q and S, that Q * 2 ^ S = (P - 1)


    var q = this.m.subn(1);
    var s = 0;

    while (!q.isZero() && q.andln(1) === 0) {
      s++;
      q.iushrn(1);
    }

    assert(!q.isZero());
    var one = new BN(1).toRed(this);
    var nOne = one.redNeg(); // Find quadratic non-residue
    // NOTE: Max is such because of generalized Riemann hypothesis.

    var lpow = this.m.subn(1).iushrn(1);
    var z = this.m.bitLength();
    z = new BN(2 * z * z).toRed(this);

    while (this.pow(z, lpow).cmp(nOne) !== 0) {
      z.redIAdd(nOne);
    }

    var c = this.pow(z, q);
    var r = this.pow(a, q.addn(1).iushrn(1));
    var t = this.pow(a, q);
    var m = s;

    while (t.cmp(one) !== 0) {
      var tmp = t;

      for (var i = 0; tmp.cmp(one) !== 0; i++) {
        tmp = tmp.redSqr();
      }

      assert(i < m);
      var b = this.pow(c, new BN(1).iushln(m - i - 1));
      r = r.redMul(b);
      c = b.redSqr();
      t = t.redMul(c);
      m = i;
    }

    return r;
  };

  Red.prototype.invm = function invm(a) {
    var inv = a._invmp(this.m);

    if (inv.negative !== 0) {
      inv.negative = 0;
      return this.imod(inv).redNeg();
    } else {
      return this.imod(inv);
    }
  };

  Red.prototype.pow = function pow(a, num) {
    if (num.isZero()) return new BN(1).toRed(this);
    if (num.cmpn(1) === 0) return a.clone();
    var windowSize = 4;
    var wnd = new Array(1 << windowSize);
    wnd[0] = new BN(1).toRed(this);
    wnd[1] = a;

    for (var i = 2; i < wnd.length; i++) {
      wnd[i] = this.mul(wnd[i - 1], a);
    }

    var res = wnd[0];
    var current = 0;
    var currentLen = 0;
    var start = num.bitLength() % 26;

    if (start === 0) {
      start = 26;
    }

    for (i = num.length - 1; i >= 0; i--) {
      var word = num.words[i];

      for (var j = start - 1; j >= 0; j--) {
        var bit = word >> j & 1;

        if (res !== wnd[0]) {
          res = this.sqr(res);
        }

        if (bit === 0 && current === 0) {
          currentLen = 0;
          continue;
        }

        current <<= 1;
        current |= bit;
        currentLen++;
        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
        res = this.mul(res, wnd[current]);
        currentLen = 0;
        current = 0;
      }

      start = 26;
    }

    return res;
  };

  Red.prototype.convertTo = function convertTo(num) {
    var r = num.umod(this.m);
    return r === num ? r.clone() : r;
  };

  Red.prototype.convertFrom = function convertFrom(num) {
    var res = num.clone();
    res.red = null;
    return res;
  }; //
  // Montgomery method engine
  //


  BN.mont = function mont(num) {
    return new Mont(num);
  };

  function Mont(m) {
    Red.call(this, m);
    this.shift = this.m.bitLength();

    if (this.shift % 26 !== 0) {
      this.shift += 26 - this.shift % 26;
    }

    this.r = new BN(1).iushln(this.shift);
    this.r2 = this.imod(this.r.sqr());
    this.rinv = this.r._invmp(this.m);
    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
    this.minv = this.minv.umod(this.r);
    this.minv = this.r.sub(this.minv);
  }

  inherits(Mont, Red);

  Mont.prototype.convertTo = function convertTo(num) {
    return this.imod(num.ushln(this.shift));
  };

  Mont.prototype.convertFrom = function convertFrom(num) {
    var r = this.imod(num.mul(this.rinv));
    r.red = null;
    return r;
  };

  Mont.prototype.imul = function imul(a, b) {
    if (a.isZero() || b.isZero()) {
      a.words[0] = 0;
      a.length = 1;
      return a;
    }

    var t = a.imul(b);
    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
    var u = t.isub(c).iushrn(this.shift);
    var res = u;

    if (u.cmp(this.m) >= 0) {
      res = u.isub(this.m);
    } else if (u.cmpn(0) < 0) {
      res = u.iadd(this.m);
    }

    return res._forceRed(this);
  };

  Mont.prototype.mul = function mul(a, b) {
    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
    var t = a.mul(b);
    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
    var u = t.isub(c).iushrn(this.shift);
    var res = u;

    if (u.cmp(this.m) >= 0) {
      res = u.isub(this.m);
    } else if (u.cmpn(0) < 0) {
      res = u.iadd(this.m);
    }

    return res._forceRed(this);
  };

  Mont.prototype.invm = function invm(a) {
    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R
    var res = this.imod(a._invmp(this.m).mul(this.r2));
    return res._forceRed(this);
  };
})( false || module, this);
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module)))

/***/ }),

/***/ "./node_modules/brorand/index.js":
/*!***************************************!*\
  !*** ./node_modules/brorand/index.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var r;

module.exports = function rand(len) {
  if (!r) r = new Rand(null);
  return r.generate(len);
};

function Rand(rand) {
  this.rand = rand;
}

module.exports.Rand = Rand;

Rand.prototype.generate = function generate(len) {
  return this._rand(len);
}; // Emulate crypto API using randy


Rand.prototype._rand = function _rand(n) {
  if (this.rand.getBytes) return this.rand.getBytes(n);
  var res = new Uint8Array(n);

  for (var i = 0; i < res.length; i++) {
    res[i] = this.rand.getByte();
  }

  return res;
};

if ((typeof self === "undefined" ? "undefined" : _typeof(self)) === 'object') {
  if (self.crypto && self.crypto.getRandomValues) {
    // Modern browsers
    Rand.prototype._rand = function _rand(n) {
      var arr = new Uint8Array(n);
      self.crypto.getRandomValues(arr);
      return arr;
    };
  } else if (self.msCrypto && self.msCrypto.getRandomValues) {
    // IE
    Rand.prototype._rand = function _rand(n) {
      var arr = new Uint8Array(n);
      self.msCrypto.getRandomValues(arr);
      return arr;
    }; // Safari's WebWorkers do not have `crypto`

  } else if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object') {
    // Old junk
    Rand.prototype._rand = function () {
      throw new Error('Not implemented yet');
    };
  }
} else {
  // Node.js or Web worker with no crypto support
  try {
    var crypto = __webpack_require__(/*! crypto */ 4);

    if (typeof crypto.randomBytes !== 'function') throw new Error('Not supported');

    Rand.prototype._rand = function _rand(n) {
      return crypto.randomBytes(n);
    };
  } catch (e) {}
}

/***/ }),

/***/ "./node_modules/browserify-aes/aes.js":
/*!********************************************!*\
  !*** ./node_modules/browserify-aes/aes.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// based on the aes implimentation in triple sec
// https://github.com/keybase/triplesec
// which is in turn based on the one from crypto-js
// https://code.google.com/p/crypto-js/
var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

function asUInt32Array(buf) {
  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
  var len = buf.length / 4 | 0;
  var out = new Array(len);

  for (var i = 0; i < len; i++) {
    out[i] = buf.readUInt32BE(i * 4);
  }

  return out;
}

function scrubVec(v) {
  for (var i = 0; i < v.length; v++) {
    v[i] = 0;
  }
}

function cryptBlock(M, keySchedule, SUB_MIX, SBOX, nRounds) {
  var SUB_MIX0 = SUB_MIX[0];
  var SUB_MIX1 = SUB_MIX[1];
  var SUB_MIX2 = SUB_MIX[2];
  var SUB_MIX3 = SUB_MIX[3];
  var s0 = M[0] ^ keySchedule[0];
  var s1 = M[1] ^ keySchedule[1];
  var s2 = M[2] ^ keySchedule[2];
  var s3 = M[3] ^ keySchedule[3];
  var t0, t1, t2, t3;
  var ksRow = 4;

  for (var round = 1; round < nRounds; round++) {
    t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[s1 >>> 16 & 0xff] ^ SUB_MIX2[s2 >>> 8 & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++];
    t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[s2 >>> 16 & 0xff] ^ SUB_MIX2[s3 >>> 8 & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++];
    t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[s3 >>> 16 & 0xff] ^ SUB_MIX2[s0 >>> 8 & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++];
    t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[s0 >>> 16 & 0xff] ^ SUB_MIX2[s1 >>> 8 & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++];
    s0 = t0;
    s1 = t1;
    s2 = t2;
    s3 = t3;
  }

  t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 0xff] << 16 | SBOX[s2 >>> 8 & 0xff] << 8 | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
  t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 0xff] << 16 | SBOX[s3 >>> 8 & 0xff] << 8 | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
  t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 0xff] << 16 | SBOX[s0 >>> 8 & 0xff] << 8 | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
  t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 0xff] << 16 | SBOX[s1 >>> 8 & 0xff] << 8 | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
  t0 = t0 >>> 0;
  t1 = t1 >>> 0;
  t2 = t2 >>> 0;
  t3 = t3 >>> 0;
  return [t0, t1, t2, t3];
} // AES constants


var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];

var G = function () {
  // Compute double table
  var d = new Array(256);

  for (var j = 0; j < 256; j++) {
    if (j < 128) {
      d[j] = j << 1;
    } else {
      d[j] = j << 1 ^ 0x11b;
    }
  }

  var SBOX = [];
  var INV_SBOX = [];
  var SUB_MIX = [[], [], [], []];
  var INV_SUB_MIX = [[], [], [], []]; // 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

    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;

    if (x === 0) {
      x = xi = 1;
    } else {
      x = x2 ^ d[d[d[x8 ^ x2]]];
      xi ^= d[d[xi]];
    }
  }

  return {
    SBOX: SBOX,
    INV_SBOX: INV_SBOX,
    SUB_MIX: SUB_MIX,
    INV_SUB_MIX: INV_SUB_MIX
  };
}();

function AES(key) {
  this._key = asUInt32Array(key);

  this._reset();
}

AES.blockSize = 4 * 4;
AES.keySize = 256 / 8;
AES.prototype.blockSize = AES.blockSize;
AES.prototype.keySize = AES.keySize;

AES.prototype._reset = function () {
  var keyWords = this._key;
  var keySize = keyWords.length;
  var nRounds = keySize + 6;
  var ksRows = (nRounds + 1) * 4;
  var keySchedule = [];

  for (var k = 0; k < keySize; k++) {
    keySchedule[k] = keyWords[k];
  }

  for (k = keySize; k < ksRows; k++) {
    var t = keySchedule[k - 1];

    if (k % keySize === 0) {
      t = t << 8 | t >>> 24;
      t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 0xff] << 16 | G.SBOX[t >>> 8 & 0xff] << 8 | G.SBOX[t & 0xff];
      t ^= RCON[k / keySize | 0] << 24;
    } else if (keySize > 6 && k % keySize === 4) {
      t = G.SBOX[t >>> 24] << 24 | G.SBOX[t >>> 16 & 0xff] << 16 | G.SBOX[t >>> 8 & 0xff] << 8 | G.SBOX[t & 0xff];
    }

    keySchedule[k] = keySchedule[k - keySize] ^ t;
  }

  var invKeySchedule = [];

  for (var ik = 0; ik < ksRows; ik++) {
    var ksR = ksRows - ik;
    var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)];

    if (ik < 4 || ksR <= 4) {
      invKeySchedule[ik] = tt;
    } else {
      invKeySchedule[ik] = G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[tt >>> 16 & 0xff]] ^ G.INV_SUB_MIX[2][G.SBOX[tt >>> 8 & 0xff]] ^ G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]];
    }
  }

  this._nRounds = nRounds;
  this._keySchedule = keySchedule;
  this._invKeySchedule = invKeySchedule;
};

AES.prototype.encryptBlockRaw = function (M) {
  M = asUInt32Array(M);
  return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds);
};

AES.prototype.encryptBlock = function (M) {
  var out = this.encryptBlockRaw(M);
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0], 0);
  buf.writeUInt32BE(out[1], 4);
  buf.writeUInt32BE(out[2], 8);
  buf.writeUInt32BE(out[3], 12);
  return buf;
};

AES.prototype.decryptBlock = function (M) {
  M = asUInt32Array(M); // swap

  var m1 = M[1];
  M[1] = M[3];
  M[3] = m1;
  var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds);
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0], 0);
  buf.writeUInt32BE(out[3], 4);
  buf.writeUInt32BE(out[2], 8);
  buf.writeUInt32BE(out[1], 12);
  return buf;
};

AES.prototype.scrub = function () {
  scrubVec(this._keySchedule);
  scrubVec(this._invKeySchedule);
  scrubVec(this._key);
};

module.exports.AES = AES;

/***/ }),

/***/ "./node_modules/browserify-aes/authCipher.js":
/*!***************************************************!*\
  !*** ./node_modules/browserify-aes/authCipher.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var aes = __webpack_require__(/*! ./aes */ "./node_modules/browserify-aes/aes.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var Transform = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var GHASH = __webpack_require__(/*! ./ghash */ "./node_modules/browserify-aes/ghash.js");

var xor = __webpack_require__(/*! buffer-xor */ "./node_modules/buffer-xor/index.js");

var incr32 = __webpack_require__(/*! ./incr32 */ "./node_modules/browserify-aes/incr32.js");

function xorTest(a, b) {
  var out = 0;
  if (a.length !== b.length) out++;
  var len = Math.min(a.length, b.length);

  for (var i = 0; i < len; ++i) {
    out += a[i] ^ b[i];
  }

  return out;
}

function calcIv(self, iv, ck) {
  if (iv.length === 12) {
    self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])]);
    return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])]);
  }

  var ghash = new GHASH(ck);
  var len = iv.length;
  var toPad = len % 16;
  ghash.update(iv);

  if (toPad) {
    toPad = 16 - toPad;
    ghash.update(Buffer.alloc(toPad, 0));
  }

  ghash.update(Buffer.alloc(8, 0));
  var ivBits = len * 8;
  var tail = Buffer.alloc(8);
  tail.writeUIntBE(ivBits, 0, 8);
  ghash.update(tail);
  self._finID = ghash.state;
  var out = Buffer.from(self._finID);
  incr32(out);
  return out;
}

function StreamCipher(mode, key, iv, decrypt) {
  Transform.call(this);
  var h = Buffer.alloc(4, 0);
  this._cipher = new aes.AES(key);

  var ck = this._cipher.encryptBlock(h);

  this._ghash = new GHASH(ck);
  iv = calcIv(this, iv, ck);
  this._prev = Buffer.from(iv);
  this._cache = Buffer.allocUnsafe(0);
  this._secCache = Buffer.allocUnsafe(0);
  this._decrypt = decrypt;
  this._alen = 0;
  this._len = 0;
  this._mode = mode;
  this._authTag = null;
  this._called = false;
}

inherits(StreamCipher, Transform);

StreamCipher.prototype._update = function (chunk) {
  if (!this._called && this._alen) {
    var rump = 16 - this._alen % 16;

    if (rump < 16) {
      rump = Buffer.alloc(rump, 0);

      this._ghash.update(rump);
    }
  }

  this._called = true;

  var out = this._mode.encrypt(this, chunk);

  if (this._decrypt) {
    this._ghash.update(chunk);
  } else {
    this._ghash.update(out);
  }

  this._len += chunk.length;
  return out;
};

StreamCipher.prototype._final = function () {
  if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data');
  var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID));
  if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data');
  this._authTag = tag;

  this._cipher.scrub();
};

StreamCipher.prototype.getAuthTag = function getAuthTag() {
  if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state');
  return this._authTag;
};

StreamCipher.prototype.setAuthTag = function setAuthTag(tag) {
  if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state');
  this._authTag = tag;
};

StreamCipher.prototype.setAAD = function setAAD(buf) {
  if (this._called) throw new Error('Attempting to set AAD in unsupported state');

  this._ghash.update(buf);

  this._alen += buf.length;
};

module.exports = StreamCipher;

/***/ }),

/***/ "./node_modules/browserify-aes/browser.js":
/*!************************************************!*\
  !*** ./node_modules/browserify-aes/browser.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var ciphers = __webpack_require__(/*! ./encrypter */ "./node_modules/browserify-aes/encrypter.js");

var deciphers = __webpack_require__(/*! ./decrypter */ "./node_modules/browserify-aes/decrypter.js");

var modes = __webpack_require__(/*! ./modes/list.json */ "./node_modules/browserify-aes/modes/list.json");

function getCiphers() {
  return Object.keys(modes);
}

exports.createCipher = exports.Cipher = ciphers.createCipher;
exports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv;
exports.createDecipher = exports.Decipher = deciphers.createDecipher;
exports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv;
exports.listCiphers = exports.getCiphers = getCiphers;

/***/ }),

/***/ "./node_modules/browserify-aes/decrypter.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/decrypter.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var AuthCipher = __webpack_require__(/*! ./authCipher */ "./node_modules/browserify-aes/authCipher.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var MODES = __webpack_require__(/*! ./modes */ "./node_modules/browserify-aes/modes/index.js");

var StreamCipher = __webpack_require__(/*! ./streamCipher */ "./node_modules/browserify-aes/streamCipher.js");

var Transform = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var aes = __webpack_require__(/*! ./aes */ "./node_modules/browserify-aes/aes.js");

var ebtk = __webpack_require__(/*! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function Decipher(mode, key, iv) {
  Transform.call(this);
  this._cache = new Splitter();
  this._last = void 0;
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._mode = mode;
  this._autopadding = true;
}

inherits(Decipher, Transform);

Decipher.prototype._update = function (data) {
  this._cache.add(data);

  var chunk;
  var thing;
  var out = [];

  while (chunk = this._cache.get(this._autopadding)) {
    thing = this._mode.decrypt(this, chunk);
    out.push(thing);
  }

  return Buffer.concat(out);
};

Decipher.prototype._final = function () {
  var chunk = this._cache.flush();

  if (this._autopadding) {
    return unpad(this._mode.decrypt(this, chunk));
  } else if (chunk) {
    throw new Error('data not multiple of block length');
  }
};

Decipher.prototype.setAutoPadding = function (setTo) {
  this._autopadding = !!setTo;
  return this;
};

function Splitter() {
  this.cache = Buffer.allocUnsafe(0);
}

Splitter.prototype.add = function (data) {
  this.cache = Buffer.concat([this.cache, data]);
};

Splitter.prototype.get = function (autoPadding) {
  var out;

  if (autoPadding) {
    if (this.cache.length > 16) {
      out = this.cache.slice(0, 16);
      this.cache = this.cache.slice(16);
      return out;
    }
  } else {
    if (this.cache.length >= 16) {
      out = this.cache.slice(0, 16);
      this.cache = this.cache.slice(16);
      return out;
    }
  }

  return null;
};

Splitter.prototype.flush = function () {
  if (this.cache.length) return this.cache;
};

function unpad(last) {
  var padded = last[15];

  if (padded < 1 || padded > 16) {
    throw new Error('unable to decrypt data');
  }

  var i = -1;

  while (++i < padded) {
    if (last[i + (16 - padded)] !== padded) {
      throw new Error('unable to decrypt data');
    }
  }

  if (padded === 16) return;
  return last.slice(0, 16 - padded);
}

function createDecipheriv(suite, password, iv) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  if (typeof iv === 'string') iv = Buffer.from(iv);
  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length);
  if (typeof password === 'string') password = Buffer.from(password);
  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length);

  if (config.type === 'stream') {
    return new StreamCipher(config.module, password, iv, true);
  } else if (config.type === 'auth') {
    return new AuthCipher(config.module, password, iv, true);
  }

  return new Decipher(config.module, password, iv);
}

function createDecipher(suite, password) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  var keys = ebtk(password, false, config.key, config.iv);
  return createDecipheriv(suite, keys.key, keys.iv);
}

exports.createDecipher = createDecipher;
exports.createDecipheriv = createDecipheriv;

/***/ }),

/***/ "./node_modules/browserify-aes/encrypter.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/encrypter.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var MODES = __webpack_require__(/*! ./modes */ "./node_modules/browserify-aes/modes/index.js");

var AuthCipher = __webpack_require__(/*! ./authCipher */ "./node_modules/browserify-aes/authCipher.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var StreamCipher = __webpack_require__(/*! ./streamCipher */ "./node_modules/browserify-aes/streamCipher.js");

var Transform = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var aes = __webpack_require__(/*! ./aes */ "./node_modules/browserify-aes/aes.js");

var ebtk = __webpack_require__(/*! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function Cipher(mode, key, iv) {
  Transform.call(this);
  this._cache = new Splitter();
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._mode = mode;
  this._autopadding = true;
}

inherits(Cipher, Transform);

Cipher.prototype._update = function (data) {
  this._cache.add(data);

  var chunk;
  var thing;
  var out = [];

  while (chunk = this._cache.get()) {
    thing = this._mode.encrypt(this, chunk);
    out.push(thing);
  }

  return Buffer.concat(out);
};

var PADDING = Buffer.alloc(16, 0x10);

Cipher.prototype._final = function () {
  var chunk = this._cache.flush();

  if (this._autopadding) {
    chunk = this._mode.encrypt(this, chunk);

    this._cipher.scrub();

    return chunk;
  }

  if (!chunk.equals(PADDING)) {
    this._cipher.scrub();

    throw new Error('data not multiple of block length');
  }
};

Cipher.prototype.setAutoPadding = function (setTo) {
  this._autopadding = !!setTo;
  return this;
};

function Splitter() {
  this.cache = Buffer.allocUnsafe(0);
}

Splitter.prototype.add = function (data) {
  this.cache = Buffer.concat([this.cache, data]);
};

Splitter.prototype.get = function () {
  if (this.cache.length > 15) {
    var out = this.cache.slice(0, 16);
    this.cache = this.cache.slice(16);
    return out;
  }

  return null;
};

Splitter.prototype.flush = function () {
  var len = 16 - this.cache.length;
  var padBuff = Buffer.allocUnsafe(len);
  var i = -1;

  while (++i < len) {
    padBuff.writeUInt8(len, i);
  }

  return Buffer.concat([this.cache, padBuff]);
};

function createCipheriv(suite, password, iv) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  if (typeof password === 'string') password = Buffer.from(password);
  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length);
  if (typeof iv === 'string') iv = Buffer.from(iv);
  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length);

  if (config.type === 'stream') {
    return new StreamCipher(config.module, password, iv);
  } else if (config.type === 'auth') {
    return new AuthCipher(config.module, password, iv);
  }

  return new Cipher(config.module, password, iv);
}

function createCipher(suite, password) {
  var config = MODES[suite.toLowerCase()];
  if (!config) throw new TypeError('invalid suite type');
  var keys = ebtk(password, false, config.key, config.iv);
  return createCipheriv(suite, keys.key, keys.iv);
}

exports.createCipheriv = createCipheriv;
exports.createCipher = createCipher;

/***/ }),

/***/ "./node_modules/browserify-aes/ghash.js":
/*!**********************************************!*\
  !*** ./node_modules/browserify-aes/ghash.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var ZEROES = Buffer.alloc(16, 0);

function toArray(buf) {
  return [buf.readUInt32BE(0), buf.readUInt32BE(4), buf.readUInt32BE(8), buf.readUInt32BE(12)];
}

function fromArray(out) {
  var buf = Buffer.allocUnsafe(16);
  buf.writeUInt32BE(out[0] >>> 0, 0);
  buf.writeUInt32BE(out[1] >>> 0, 4);
  buf.writeUInt32BE(out[2] >>> 0, 8);
  buf.writeUInt32BE(out[3] >>> 0, 12);
  return buf;
}

function GHASH(key) {
  this.h = key;
  this.state = Buffer.alloc(16, 0);
  this.cache = Buffer.allocUnsafe(0);
} // from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html
// by Juho Vähä-Herttua


GHASH.prototype.ghash = function (block) {
  var i = -1;

  while (++i < block.length) {
    this.state[i] ^= block[i];
  }

  this._multiply();
};

GHASH.prototype._multiply = function () {
  var Vi = toArray(this.h);
  var Zi = [0, 0, 0, 0];
  var j, xi, lsbVi;
  var i = -1;

  while (++i < 128) {
    xi = (this.state[~~(i / 8)] & 1 << 7 - i % 8) !== 0;

    if (xi) {
      // Z_i+1 = Z_i ^ V_i
      Zi[0] ^= Vi[0];
      Zi[1] ^= Vi[1];
      Zi[2] ^= Vi[2];
      Zi[3] ^= Vi[3];
    } // Store the value of LSB(V_i)


    lsbVi = (Vi[3] & 1) !== 0; // V_i+1 = V_i >> 1

    for (j = 3; j > 0; j--) {
      Vi[j] = Vi[j] >>> 1 | (Vi[j - 1] & 1) << 31;
    }

    Vi[0] = Vi[0] >>> 1; // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R

    if (lsbVi) {
      Vi[0] = Vi[0] ^ 0xe1 << 24;
    }
  }

  this.state = fromArray(Zi);
};

GHASH.prototype.update = function (buf) {
  this.cache = Buffer.concat([this.cache, buf]);
  var chunk;

  while (this.cache.length >= 16) {
    chunk = this.cache.slice(0, 16);
    this.cache = this.cache.slice(16);
    this.ghash(chunk);
  }
};

GHASH.prototype.final = function (abl, bl) {
  if (this.cache.length) {
    this.ghash(Buffer.concat([this.cache, ZEROES], 16));
  }

  this.ghash(fromArray([0, abl, 0, bl]));
  return this.state;
};

module.exports = GHASH;

/***/ }),

/***/ "./node_modules/browserify-aes/incr32.js":
/*!***********************************************!*\
  !*** ./node_modules/browserify-aes/incr32.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

function incr32(iv) {
  var len = iv.length;
  var item;

  while (len--) {
    item = iv.readUInt8(len);

    if (item === 255) {
      iv.writeUInt8(0, len);
    } else {
      item++;
      iv.writeUInt8(item, len);
      break;
    }
  }
}

module.exports = incr32;

/***/ }),

/***/ "./node_modules/browserify-aes/modes/cbc.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/modes/cbc.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var xor = __webpack_require__(/*! buffer-xor */ "./node_modules/buffer-xor/index.js");

exports.encrypt = function (self, block) {
  var data = xor(block, self._prev);
  self._prev = self._cipher.encryptBlock(data);
  return self._prev;
};

exports.decrypt = function (self, block) {
  var pad = self._prev;
  self._prev = block;

  var out = self._cipher.decryptBlock(block);

  return xor(out, pad);
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/cfb.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/modes/cfb.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var xor = __webpack_require__(/*! buffer-xor */ "./node_modules/buffer-xor/index.js");

function encryptStart(self, data, decrypt) {
  var len = data.length;
  var out = xor(data, self._cache);
  self._cache = self._cache.slice(len);
  self._prev = Buffer.concat([self._prev, decrypt ? data : out]);
  return out;
}

exports.encrypt = function (self, data, decrypt) {
  var out = Buffer.allocUnsafe(0);
  var len;

  while (data.length) {
    if (self._cache.length === 0) {
      self._cache = self._cipher.encryptBlock(self._prev);
      self._prev = Buffer.allocUnsafe(0);
    }

    if (self._cache.length <= data.length) {
      len = self._cache.length;
      out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)]);
      data = data.slice(len);
    } else {
      out = Buffer.concat([out, encryptStart(self, data, decrypt)]);
      break;
    }
  }

  return out;
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/cfb1.js":
/*!***************************************************!*\
  !*** ./node_modules/browserify-aes/modes/cfb1.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

function encryptByte(self, byteParam, decrypt) {
  var pad;
  var i = -1;
  var len = 8;
  var out = 0;
  var bit, value;

  while (++i < len) {
    pad = self._cipher.encryptBlock(self._prev);
    bit = byteParam & 1 << 7 - i ? 0x80 : 0;
    value = pad[0] ^ bit;
    out += (value & 0x80) >> i % 8;
    self._prev = shiftIn(self._prev, decrypt ? bit : value);
  }

  return out;
}

function shiftIn(buffer, value) {
  var len = buffer.length;
  var i = -1;
  var out = Buffer.allocUnsafe(buffer.length);
  buffer = Buffer.concat([buffer, Buffer.from([value])]);

  while (++i < len) {
    out[i] = buffer[i] << 1 | buffer[i + 1] >> 7;
  }

  return out;
}

exports.encrypt = function (self, chunk, decrypt) {
  var len = chunk.length;
  var out = Buffer.allocUnsafe(len);
  var i = -1;

  while (++i < len) {
    out[i] = encryptByte(self, chunk[i], decrypt);
  }

  return out;
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/cfb8.js":
/*!***************************************************!*\
  !*** ./node_modules/browserify-aes/modes/cfb8.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

function encryptByte(self, byteParam, decrypt) {
  var pad = self._cipher.encryptBlock(self._prev);

  var out = pad[0] ^ byteParam;
  self._prev = Buffer.concat([self._prev.slice(1), Buffer.from([decrypt ? byteParam : out])]);
  return out;
}

exports.encrypt = function (self, chunk, decrypt) {
  var len = chunk.length;
  var out = Buffer.allocUnsafe(len);
  var i = -1;

  while (++i < len) {
    out[i] = encryptByte(self, chunk[i], decrypt);
  }

  return out;
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/ctr.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/modes/ctr.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var xor = __webpack_require__(/*! buffer-xor */ "./node_modules/buffer-xor/index.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var incr32 = __webpack_require__(/*! ../incr32 */ "./node_modules/browserify-aes/incr32.js");

function getBlock(self) {
  var out = self._cipher.encryptBlockRaw(self._prev);

  incr32(self._prev);
  return out;
}

var blockSize = 16;

exports.encrypt = function (self, chunk) {
  var chunkNum = Math.ceil(chunk.length / blockSize);
  var start = self._cache.length;
  self._cache = Buffer.concat([self._cache, Buffer.allocUnsafe(chunkNum * blockSize)]);

  for (var i = 0; i < chunkNum; i++) {
    var out = getBlock(self);
    var offset = start + i * blockSize;

    self._cache.writeUInt32BE(out[0], offset + 0);

    self._cache.writeUInt32BE(out[1], offset + 4);

    self._cache.writeUInt32BE(out[2], offset + 8);

    self._cache.writeUInt32BE(out[3], offset + 12);
  }

  var pad = self._cache.slice(0, chunk.length);

  self._cache = self._cache.slice(chunk.length);
  return xor(chunk, pad);
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/ecb.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/modes/ecb.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

exports.encrypt = function (self, block) {
  return self._cipher.encryptBlock(block);
};

exports.decrypt = function (self, block) {
  return self._cipher.decryptBlock(block);
};

/***/ }),

/***/ "./node_modules/browserify-aes/modes/index.js":
/*!****************************************************!*\
  !*** ./node_modules/browserify-aes/modes/index.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var modeModules = {
  ECB: __webpack_require__(/*! ./ecb */ "./node_modules/browserify-aes/modes/ecb.js"),
  CBC: __webpack_require__(/*! ./cbc */ "./node_modules/browserify-aes/modes/cbc.js"),
  CFB: __webpack_require__(/*! ./cfb */ "./node_modules/browserify-aes/modes/cfb.js"),
  CFB8: __webpack_require__(/*! ./cfb8 */ "./node_modules/browserify-aes/modes/cfb8.js"),
  CFB1: __webpack_require__(/*! ./cfb1 */ "./node_modules/browserify-aes/modes/cfb1.js"),
  OFB: __webpack_require__(/*! ./ofb */ "./node_modules/browserify-aes/modes/ofb.js"),
  CTR: __webpack_require__(/*! ./ctr */ "./node_modules/browserify-aes/modes/ctr.js"),
  GCM: __webpack_require__(/*! ./ctr */ "./node_modules/browserify-aes/modes/ctr.js")
};

var modes = __webpack_require__(/*! ./list.json */ "./node_modules/browserify-aes/modes/list.json");

for (var key in modes) {
  modes[key].module = modeModules[modes[key].mode];
}

module.exports = modes;

/***/ }),

/***/ "./node_modules/browserify-aes/modes/list.json":
/*!*****************************************************!*\
  !*** ./node_modules/browserify-aes/modes/list.json ***!
  \*****************************************************/
/*! exports provided: aes-128-ecb, aes-192-ecb, aes-256-ecb, aes-128-cbc, aes-192-cbc, aes-256-cbc, aes128, aes192, aes256, aes-128-cfb, aes-192-cfb, aes-256-cfb, aes-128-cfb8, aes-192-cfb8, aes-256-cfb8, aes-128-cfb1, aes-192-cfb1, aes-256-cfb1, aes-128-ofb, aes-192-ofb, aes-256-ofb, aes-128-ctr, aes-192-ctr, aes-256-ctr, aes-128-gcm, aes-192-gcm, aes-256-gcm, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"aes-128-ecb\":{\"cipher\":\"AES\",\"key\":128,\"iv\":0,\"mode\":\"ECB\",\"type\":\"block\"},\"aes-192-ecb\":{\"cipher\":\"AES\",\"key\":192,\"iv\":0,\"mode\":\"ECB\",\"type\":\"block\"},\"aes-256-ecb\":{\"cipher\":\"AES\",\"key\":256,\"iv\":0,\"mode\":\"ECB\",\"type\":\"block\"},\"aes-128-cbc\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes-192-cbc\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes-256-cbc\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes128\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes192\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes256\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CBC\",\"type\":\"block\"},\"aes-128-cfb\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CFB\",\"type\":\"stream\"},\"aes-192-cfb\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CFB\",\"type\":\"stream\"},\"aes-256-cfb\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CFB\",\"type\":\"stream\"},\"aes-128-cfb8\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CFB8\",\"type\":\"stream\"},\"aes-192-cfb8\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CFB8\",\"type\":\"stream\"},\"aes-256-cfb8\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CFB8\",\"type\":\"stream\"},\"aes-128-cfb1\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CFB1\",\"type\":\"stream\"},\"aes-192-cfb1\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CFB1\",\"type\":\"stream\"},\"aes-256-cfb1\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CFB1\",\"type\":\"stream\"},\"aes-128-ofb\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"OFB\",\"type\":\"stream\"},\"aes-192-ofb\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"OFB\",\"type\":\"stream\"},\"aes-256-ofb\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"OFB\",\"type\":\"stream\"},\"aes-128-ctr\":{\"cipher\":\"AES\",\"key\":128,\"iv\":16,\"mode\":\"CTR\",\"type\":\"stream\"},\"aes-192-ctr\":{\"cipher\":\"AES\",\"key\":192,\"iv\":16,\"mode\":\"CTR\",\"type\":\"stream\"},\"aes-256-ctr\":{\"cipher\":\"AES\",\"key\":256,\"iv\":16,\"mode\":\"CTR\",\"type\":\"stream\"},\"aes-128-gcm\":{\"cipher\":\"AES\",\"key\":128,\"iv\":12,\"mode\":\"GCM\",\"type\":\"auth\"},\"aes-192-gcm\":{\"cipher\":\"AES\",\"key\":192,\"iv\":12,\"mode\":\"GCM\",\"type\":\"auth\"},\"aes-256-gcm\":{\"cipher\":\"AES\",\"key\":256,\"iv\":12,\"mode\":\"GCM\",\"type\":\"auth\"}}");

/***/ }),

/***/ "./node_modules/browserify-aes/modes/ofb.js":
/*!**************************************************!*\
  !*** ./node_modules/browserify-aes/modes/ofb.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var xor = __webpack_require__(/*! buffer-xor */ "./node_modules/buffer-xor/index.js");

function getBlock(self) {
  self._prev = self._cipher.encryptBlock(self._prev);
  return self._prev;
}

exports.encrypt = function (self, chunk) {
  while (self._cache.length < chunk.length) {
    self._cache = Buffer.concat([self._cache, getBlock(self)]);
  }

  var pad = self._cache.slice(0, chunk.length);

  self._cache = self._cache.slice(chunk.length);
  return xor(chunk, pad);
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/browserify-aes/streamCipher.js":
/*!*****************************************************!*\
  !*** ./node_modules/browserify-aes/streamCipher.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var aes = __webpack_require__(/*! ./aes */ "./node_modules/browserify-aes/aes.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var Transform = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function StreamCipher(mode, key, iv, decrypt) {
  Transform.call(this);
  this._cipher = new aes.AES(key);
  this._prev = Buffer.from(iv);
  this._cache = Buffer.allocUnsafe(0);
  this._secCache = Buffer.allocUnsafe(0);
  this._decrypt = decrypt;
  this._mode = mode;
}

inherits(StreamCipher, Transform);

StreamCipher.prototype._update = function (chunk) {
  return this._mode.encrypt(this, chunk, this._decrypt);
};

StreamCipher.prototype._final = function () {
  this._cipher.scrub();
};

module.exports = StreamCipher;

/***/ }),

/***/ "./node_modules/browserify-cipher/browser.js":
/*!***************************************************!*\
  !*** ./node_modules/browserify-cipher/browser.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var DES = __webpack_require__(/*! browserify-des */ "./node_modules/browserify-des/index.js");

var aes = __webpack_require__(/*! browserify-aes/browser */ "./node_modules/browserify-aes/browser.js");

var aesModes = __webpack_require__(/*! browserify-aes/modes */ "./node_modules/browserify-aes/modes/index.js");

var desModes = __webpack_require__(/*! browserify-des/modes */ "./node_modules/browserify-des/modes.js");

var ebtk = __webpack_require__(/*! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js");

function createCipher(suite, password) {
  suite = suite.toLowerCase();
  var keyLen, ivLen;

  if (aesModes[suite]) {
    keyLen = aesModes[suite].key;
    ivLen = aesModes[suite].iv;
  } else if (desModes[suite]) {
    keyLen = desModes[suite].key * 8;
    ivLen = desModes[suite].iv;
  } else {
    throw new TypeError('invalid suite type');
  }

  var keys = ebtk(password, false, keyLen, ivLen);
  return createCipheriv(suite, keys.key, keys.iv);
}

function createDecipher(suite, password) {
  suite = suite.toLowerCase();
  var keyLen, ivLen;

  if (aesModes[suite]) {
    keyLen = aesModes[suite].key;
    ivLen = aesModes[suite].iv;
  } else if (desModes[suite]) {
    keyLen = desModes[suite].key * 8;
    ivLen = desModes[suite].iv;
  } else {
    throw new TypeError('invalid suite type');
  }

  var keys = ebtk(password, false, keyLen, ivLen);
  return createDecipheriv(suite, keys.key, keys.iv);
}

function createCipheriv(suite, key, iv) {
  suite = suite.toLowerCase();
  if (aesModes[suite]) return aes.createCipheriv(suite, key, iv);
  if (desModes[suite]) return new DES({
    key: key,
    iv: iv,
    mode: suite
  });
  throw new TypeError('invalid suite type');
}

function createDecipheriv(suite, key, iv) {
  suite = suite.toLowerCase();
  if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv);
  if (desModes[suite]) return new DES({
    key: key,
    iv: iv,
    mode: suite,
    decrypt: true
  });
  throw new TypeError('invalid suite type');
}

function getCiphers() {
  return Object.keys(desModes).concat(aes.getCiphers());
}

exports.createCipher = exports.Cipher = createCipher;
exports.createCipheriv = exports.Cipheriv = createCipheriv;
exports.createDecipher = exports.Decipher = createDecipher;
exports.createDecipheriv = exports.Decipheriv = createDecipheriv;
exports.listCiphers = exports.getCiphers = getCiphers;

/***/ }),

/***/ "./node_modules/browserify-des/index.js":
/*!**********************************************!*\
  !*** ./node_modules/browserify-des/index.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var CipherBase = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var des = __webpack_require__(/*! des.js */ "./node_modules/des.js/lib/des.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var modes = {
  'des-ede3-cbc': des.CBC.instantiate(des.EDE),
  'des-ede3': des.EDE,
  'des-ede-cbc': des.CBC.instantiate(des.EDE),
  'des-ede': des.EDE,
  'des-cbc': des.CBC.instantiate(des.DES),
  'des-ecb': des.DES
};
modes.des = modes['des-cbc'];
modes.des3 = modes['des-ede3-cbc'];
module.exports = DES;
inherits(DES, CipherBase);

function DES(opts) {
  CipherBase.call(this);
  var modeName = opts.mode.toLowerCase();
  var mode = modes[modeName];
  var type;

  if (opts.decrypt) {
    type = 'decrypt';
  } else {
    type = 'encrypt';
  }

  var key = opts.key;

  if (!Buffer.isBuffer(key)) {
    key = Buffer.from(key);
  }

  if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {
    key = Buffer.concat([key, key.slice(0, 8)]);
  }

  var iv = opts.iv;

  if (!Buffer.isBuffer(iv)) {
    iv = Buffer.from(iv);
  }

  this._des = mode.create({
    key: key,
    iv: iv,
    type: type
  });
}

DES.prototype._update = function (data) {
  return Buffer.from(this._des.update(data));
};

DES.prototype._final = function () {
  return Buffer.from(this._des.final());
};

/***/ }),

/***/ "./node_modules/browserify-des/modes.js":
/*!**********************************************!*\
  !*** ./node_modules/browserify-des/modes.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

exports['des-ecb'] = {
  key: 8,
  iv: 0
};
exports['des-cbc'] = exports.des = {
  key: 8,
  iv: 8
};
exports['des-ede3-cbc'] = exports.des3 = {
  key: 24,
  iv: 8
};
exports['des-ede3'] = {
  key: 24,
  iv: 0
};
exports['des-ede-cbc'] = {
  key: 16,
  iv: 8
};
exports['des-ede'] = {
  key: 16,
  iv: 0
};

/***/ }),

/***/ "./node_modules/browserify-rsa/index.js":
/*!**********************************************!*\
  !*** ./node_modules/browserify-rsa/index.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var bn = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var randomBytes = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");

module.exports = crt;

function blind(priv) {
  var r = getr(priv);
  var blinder = r.toRed(bn.mont(priv.modulus)).redPow(new bn(priv.publicExponent)).fromRed();
  return {
    blinder: blinder,
    unblinder: r.invm(priv.modulus)
  };
}

function crt(msg, priv) {
  var blinds = blind(priv);
  var len = priv.modulus.byteLength();
  var mod = bn.mont(priv.modulus);
  var blinded = new bn(msg).mul(blinds.blinder).umod(priv.modulus);
  var c1 = blinded.toRed(bn.mont(priv.prime1));
  var c2 = blinded.toRed(bn.mont(priv.prime2));
  var qinv = priv.coefficient;
  var p = priv.prime1;
  var q = priv.prime2;
  var m1 = c1.redPow(priv.exponent1);
  var m2 = c2.redPow(priv.exponent2);
  m1 = m1.fromRed();
  m2 = m2.fromRed();
  var h = m1.isub(m2).imul(qinv).umod(p);
  h.imul(q);
  m2.iadd(h);
  return new Buffer(m2.imul(blinds.unblinder).umod(priv.modulus).toArray(false, len));
}

crt.getr = getr;

function getr(priv) {
  var len = priv.modulus.byteLength();
  var r = new bn(randomBytes(len));

  while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2)) {
    r = new bn(randomBytes(len));
  }

  return r;
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/browserify-sign/algos.js":
/*!***********************************************!*\
  !*** ./node_modules/browserify-sign/algos.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./browser/algorithms.json */ "./node_modules/browserify-sign/browser/algorithms.json");

/***/ }),

/***/ "./node_modules/browserify-sign/browser/algorithms.json":
/*!**************************************************************!*\
  !*** ./node_modules/browserify-sign/browser/algorithms.json ***!
  \**************************************************************/
/*! exports provided: sha224WithRSAEncryption, RSA-SHA224, sha256WithRSAEncryption, RSA-SHA256, sha384WithRSAEncryption, RSA-SHA384, sha512WithRSAEncryption, RSA-SHA512, RSA-SHA1, ecdsa-with-SHA1, sha256, sha224, sha384, sha512, DSA-SHA, DSA-SHA1, DSA, DSA-WITH-SHA224, DSA-SHA224, DSA-WITH-SHA256, DSA-SHA256, DSA-WITH-SHA384, DSA-SHA384, DSA-WITH-SHA512, DSA-SHA512, DSA-RIPEMD160, ripemd160WithRSA, RSA-RIPEMD160, md5WithRSAEncryption, RSA-MD5, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"sha224WithRSAEncryption\":{\"sign\":\"rsa\",\"hash\":\"sha224\",\"id\":\"302d300d06096086480165030402040500041c\"},\"RSA-SHA224\":{\"sign\":\"ecdsa/rsa\",\"hash\":\"sha224\",\"id\":\"302d300d06096086480165030402040500041c\"},\"sha256WithRSAEncryption\":{\"sign\":\"rsa\",\"hash\":\"sha256\",\"id\":\"3031300d060960864801650304020105000420\"},\"RSA-SHA256\":{\"sign\":\"ecdsa/rsa\",\"hash\":\"sha256\",\"id\":\"3031300d060960864801650304020105000420\"},\"sha384WithRSAEncryption\":{\"sign\":\"rsa\",\"hash\":\"sha384\",\"id\":\"3041300d060960864801650304020205000430\"},\"RSA-SHA384\":{\"sign\":\"ecdsa/rsa\",\"hash\":\"sha384\",\"id\":\"3041300d060960864801650304020205000430\"},\"sha512WithRSAEncryption\":{\"sign\":\"rsa\",\"hash\":\"sha512\",\"id\":\"3051300d060960864801650304020305000440\"},\"RSA-SHA512\":{\"sign\":\"ecdsa/rsa\",\"hash\":\"sha512\",\"id\":\"3051300d060960864801650304020305000440\"},\"RSA-SHA1\":{\"sign\":\"rsa\",\"hash\":\"sha1\",\"id\":\"3021300906052b0e03021a05000414\"},\"ecdsa-with-SHA1\":{\"sign\":\"ecdsa\",\"hash\":\"sha1\",\"id\":\"\"},\"sha256\":{\"sign\":\"ecdsa\",\"hash\":\"sha256\",\"id\":\"\"},\"sha224\":{\"sign\":\"ecdsa\",\"hash\":\"sha224\",\"id\":\"\"},\"sha384\":{\"sign\":\"ecdsa\",\"hash\":\"sha384\",\"id\":\"\"},\"sha512\":{\"sign\":\"ecdsa\",\"hash\":\"sha512\",\"id\":\"\"},\"DSA-SHA\":{\"sign\":\"dsa\",\"hash\":\"sha1\",\"id\":\"\"},\"DSA-SHA1\":{\"sign\":\"dsa\",\"hash\":\"sha1\",\"id\":\"\"},\"DSA\":{\"sign\":\"dsa\",\"hash\":\"sha1\",\"id\":\"\"},\"DSA-WITH-SHA224\":{\"sign\":\"dsa\",\"hash\":\"sha224\",\"id\":\"\"},\"DSA-SHA224\":{\"sign\":\"dsa\",\"hash\":\"sha224\",\"id\":\"\"},\"DSA-WITH-SHA256\":{\"sign\":\"dsa\",\"hash\":\"sha256\",\"id\":\"\"},\"DSA-SHA256\":{\"sign\":\"dsa\",\"hash\":\"sha256\",\"id\":\"\"},\"DSA-WITH-SHA384\":{\"sign\":\"dsa\",\"hash\":\"sha384\",\"id\":\"\"},\"DSA-SHA384\":{\"sign\":\"dsa\",\"hash\":\"sha384\",\"id\":\"\"},\"DSA-WITH-SHA512\":{\"sign\":\"dsa\",\"hash\":\"sha512\",\"id\":\"\"},\"DSA-SHA512\":{\"sign\":\"dsa\",\"hash\":\"sha512\",\"id\":\"\"},\"DSA-RIPEMD160\":{\"sign\":\"dsa\",\"hash\":\"rmd160\",\"id\":\"\"},\"ripemd160WithRSA\":{\"sign\":\"rsa\",\"hash\":\"rmd160\",\"id\":\"3021300906052b2403020105000414\"},\"RSA-RIPEMD160\":{\"sign\":\"rsa\",\"hash\":\"rmd160\",\"id\":\"3021300906052b2403020105000414\"},\"md5WithRSAEncryption\":{\"sign\":\"rsa\",\"hash\":\"md5\",\"id\":\"3020300c06082a864886f70d020505000410\"},\"RSA-MD5\":{\"sign\":\"rsa\",\"hash\":\"md5\",\"id\":\"3020300c06082a864886f70d020505000410\"}}");

/***/ }),

/***/ "./node_modules/browserify-sign/browser/curves.json":
/*!**********************************************************!*\
  !*** ./node_modules/browserify-sign/browser/curves.json ***!
  \**********************************************************/
/*! exports provided: 1.3.132.0.10, 1.3.132.0.33, 1.2.840.10045.3.1.1, 1.2.840.10045.3.1.7, 1.3.132.0.34, 1.3.132.0.35, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"1.3.132.0.10\":\"secp256k1\",\"1.3.132.0.33\":\"p224\",\"1.2.840.10045.3.1.1\":\"p192\",\"1.2.840.10045.3.1.7\":\"p256\",\"1.3.132.0.34\":\"p384\",\"1.3.132.0.35\":\"p521\"}");

/***/ }),

/***/ "./node_modules/browserify-sign/browser/index.js":
/*!*******************************************************!*\
  !*** ./node_modules/browserify-sign/browser/index.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(/*! create-hash */ "./node_modules/create-hash/browser.js");

var stream = __webpack_require__(/*! stream */ "./node_modules/stream-browserify/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var sign = __webpack_require__(/*! ./sign */ "./node_modules/browserify-sign/browser/sign.js");

var verify = __webpack_require__(/*! ./verify */ "./node_modules/browserify-sign/browser/verify.js");

var algorithms = __webpack_require__(/*! ./algorithms.json */ "./node_modules/browserify-sign/browser/algorithms.json");

Object.keys(algorithms).forEach(function (key) {
  algorithms[key].id = new Buffer(algorithms[key].id, 'hex');
  algorithms[key.toLowerCase()] = algorithms[key];
});

function Sign(algorithm) {
  stream.Writable.call(this);
  var data = algorithms[algorithm];
  if (!data) throw new Error('Unknown message digest');
  this._hashType = data.hash;
  this._hash = createHash(data.hash);
  this._tag = data.id;
  this._signType = data.sign;
}

inherits(Sign, stream.Writable);

Sign.prototype._write = function _write(data, _, done) {
  this._hash.update(data);

  done();
};

Sign.prototype.update = function update(data, enc) {
  if (typeof data === 'string') data = new Buffer(data, enc);

  this._hash.update(data);

  return this;
};

Sign.prototype.sign = function signMethod(key, enc) {
  this.end();

  var hash = this._hash.digest();

  var sig = sign(hash, key, this._hashType, this._signType, this._tag);
  return enc ? sig.toString(enc) : sig;
};

function Verify(algorithm) {
  stream.Writable.call(this);
  var data = algorithms[algorithm];
  if (!data) throw new Error('Unknown message digest');
  this._hash = createHash(data.hash);
  this._tag = data.id;
  this._signType = data.sign;
}

inherits(Verify, stream.Writable);

Verify.prototype._write = function _write(data, _, done) {
  this._hash.update(data);

  done();
};

Verify.prototype.update = function update(data, enc) {
  if (typeof data === 'string') data = new Buffer(data, enc);

  this._hash.update(data);

  return this;
};

Verify.prototype.verify = function verifyMethod(key, sig, enc) {
  if (typeof sig === 'string') sig = new Buffer(sig, enc);
  this.end();

  var hash = this._hash.digest();

  return verify(sig, hash, key, this._signType, this._tag);
};

function createSign(algorithm) {
  return new Sign(algorithm);
}

function createVerify(algorithm) {
  return new Verify(algorithm);
}

module.exports = {
  Sign: createSign,
  Verify: createVerify,
  createSign: createSign,
  createVerify: createVerify
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/browserify-sign/browser/sign.js":
/*!******************************************************!*\
  !*** ./node_modules/browserify-sign/browser/sign.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
var createHmac = __webpack_require__(/*! create-hmac */ "./node_modules/create-hmac/browser.js");

var crt = __webpack_require__(/*! browserify-rsa */ "./node_modules/browserify-rsa/index.js");

var EC = __webpack_require__(/*! elliptic */ "./node_modules/elliptic/lib/elliptic.js").ec;

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var parseKeys = __webpack_require__(/*! parse-asn1 */ "./node_modules/parse-asn1/index.js");

var curves = __webpack_require__(/*! ./curves.json */ "./node_modules/browserify-sign/browser/curves.json");

function sign(hash, key, hashType, signType, tag) {
  var priv = parseKeys(key);

  if (priv.curve) {
    // rsa keys can be interpreted as ecdsa ones in openssl
    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type');
    return ecSign(hash, priv);
  } else if (priv.type === 'dsa') {
    if (signType !== 'dsa') throw new Error('wrong private key type');
    return dsaSign(hash, priv, hashType);
  } else {
    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type');
  }

  hash = Buffer.concat([tag, hash]);
  var len = priv.modulus.byteLength();
  var pad = [0, 1];

  while (hash.length + pad.length + 1 < len) {
    pad.push(0xff);
  }

  pad.push(0x00);
  var i = -1;

  while (++i < hash.length) {
    pad.push(hash[i]);
  }

  var out = crt(pad, priv);
  return out;
}

function ecSign(hash, priv) {
  var curveId = curves[priv.curve.join('.')];
  if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'));
  var curve = new EC(curveId);
  var key = curve.keyFromPrivate(priv.privateKey);
  var out = key.sign(hash);
  return new Buffer(out.toDER());
}

function dsaSign(hash, priv, algo) {
  var x = priv.params.priv_key;
  var p = priv.params.p;
  var q = priv.params.q;
  var g = priv.params.g;
  var r = new BN(0);
  var k;
  var H = bits2int(hash, q).mod(q);
  var s = false;
  var kv = getKey(x, q, hash, algo);

  while (s === false) {
    k = makeKey(q, kv, algo);
    r = makeR(g, k, p, q);
    s = k.invm(q).imul(H.add(x.mul(r))).mod(q);

    if (s.cmpn(0) === 0) {
      s = false;
      r = new BN(0);
    }
  }

  return toDER(r, s);
}

function toDER(r, s) {
  r = r.toArray();
  s = s.toArray(); // Pad values

  if (r[0] & 0x80) r = [0].concat(r);
  if (s[0] & 0x80) s = [0].concat(s);
  var total = r.length + s.length + 4;
  var res = [0x30, total, 0x02, r.length];
  res = res.concat(r, [0x02, s.length], s);
  return new Buffer(res);
}

function getKey(x, q, hash, algo) {
  x = new Buffer(x.toArray());

  if (x.length < q.byteLength()) {
    var zeros = new Buffer(q.byteLength() - x.length);
    zeros.fill(0);
    x = Buffer.concat([zeros, x]);
  }

  var hlen = hash.length;
  var hbits = bits2octets(hash, q);
  var v = new Buffer(hlen);
  v.fill(1);
  var k = new Buffer(hlen);
  k.fill(0);
  k = createHmac(algo, k).update(v).update(new Buffer([0])).update(x).update(hbits).digest();
  v = createHmac(algo, k).update(v).digest();
  k = createHmac(algo, k).update(v).update(new Buffer([1])).update(x).update(hbits).digest();
  v = createHmac(algo, k).update(v).digest();
  return {
    k: k,
    v: v
  };
}

function bits2int(obits, q) {
  var bits = new BN(obits);
  var shift = (obits.length << 3) - q.bitLength();
  if (shift > 0) bits.ishrn(shift);
  return bits;
}

function bits2octets(bits, q) {
  bits = bits2int(bits, q);
  bits = bits.mod(q);
  var out = new Buffer(bits.toArray());

  if (out.length < q.byteLength()) {
    var zeros = new Buffer(q.byteLength() - out.length);
    zeros.fill(0);
    out = Buffer.concat([zeros, out]);
  }

  return out;
}

function makeKey(q, kv, algo) {
  var t;
  var k;

  do {
    t = new Buffer(0);

    while (t.length * 8 < q.bitLength()) {
      kv.v = createHmac(algo, kv.k).update(kv.v).digest();
      t = Buffer.concat([t, kv.v]);
    }

    k = bits2int(t, q);
    kv.k = createHmac(algo, kv.k).update(kv.v).update(new Buffer([0])).digest();
    kv.v = createHmac(algo, kv.k).update(kv.v).digest();
  } while (k.cmp(q) !== -1);

  return k;
}

function makeR(g, k, p, q) {
  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q);
}

module.exports = sign;
module.exports.getKey = getKey;
module.exports.makeKey = makeKey;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/browserify-sign/browser/verify.js":
/*!********************************************************!*\
  !*** ./node_modules/browserify-sign/browser/verify.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js
var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var EC = __webpack_require__(/*! elliptic */ "./node_modules/elliptic/lib/elliptic.js").ec;

var parseKeys = __webpack_require__(/*! parse-asn1 */ "./node_modules/parse-asn1/index.js");

var curves = __webpack_require__(/*! ./curves.json */ "./node_modules/browserify-sign/browser/curves.json");

function verify(sig, hash, key, signType, tag) {
  var pub = parseKeys(key);

  if (pub.type === 'ec') {
    // rsa keys can be interpreted as ecdsa ones in openssl
    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type');
    return ecVerify(sig, hash, pub);
  } else if (pub.type === 'dsa') {
    if (signType !== 'dsa') throw new Error('wrong public key type');
    return dsaVerify(sig, hash, pub);
  } else {
    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type');
  }

  hash = Buffer.concat([tag, hash]);
  var len = pub.modulus.byteLength();
  var pad = [1];
  var padNum = 0;

  while (hash.length + pad.length + 2 < len) {
    pad.push(0xff);
    padNum++;
  }

  pad.push(0x00);
  var i = -1;

  while (++i < hash.length) {
    pad.push(hash[i]);
  }

  pad = new Buffer(pad);
  var red = BN.mont(pub.modulus);
  sig = new BN(sig).toRed(red);
  sig = sig.redPow(new BN(pub.publicExponent));
  sig = new Buffer(sig.fromRed().toArray());
  var out = padNum < 8 ? 1 : 0;
  len = Math.min(sig.length, pad.length);
  if (sig.length !== pad.length) out = 1;
  i = -1;

  while (++i < len) {
    out |= sig[i] ^ pad[i];
  }

  return out === 0;
}

function ecVerify(sig, hash, pub) {
  var curveId = curves[pub.data.algorithm.curve.join('.')];
  if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'));
  var curve = new EC(curveId);
  var pubkey = pub.data.subjectPrivateKey.data;
  return curve.verify(hash, sig, pubkey);
}

function dsaVerify(sig, hash, pub) {
  var p = pub.data.p;
  var q = pub.data.q;
  var g = pub.data.g;
  var y = pub.data.pub_key;
  var unpacked = parseKeys.signature.decode(sig, 'der');
  var s = unpacked.s;
  var r = unpacked.r;
  checkValue(s, q);
  checkValue(r, q);
  var montp = BN.mont(p);
  var w = s.invm(q);
  var v = g.toRed(montp).redPow(new BN(hash).mul(w).mod(q)).fromRed().mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed()).mod(p).mod(q);
  return v.cmp(r) === 0;
}

function checkValue(b, q) {
  if (b.cmpn(0) <= 0) throw new Error('invalid sig');
  if (b.cmp(q) >= q) throw new Error('invalid sig');
}

module.exports = verify;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/buffer-xor/index.js":
/*!******************************************!*\
  !*** ./node_modules/buffer-xor/index.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {module.exports = function xor(a, b) {
  var length = Math.min(a.length, b.length);
  var buffer = new Buffer(length);

  for (var i = 0; i < length; ++i) {
    buffer[i] = a[i] ^ b[i];
  }

  return buffer;
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/cipher-base/index.js":
/*!*******************************************!*\
  !*** ./node_modules/cipher-base/index.js ***!
  \*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var Transform = __webpack_require__(/*! stream */ "./node_modules/stream-browserify/index.js").Transform;

var StringDecoder = __webpack_require__(/*! string_decoder */ "./node_modules/string_decoder/lib/string_decoder.js").StringDecoder;

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function CipherBase(hashMode) {
  Transform.call(this);
  this.hashMode = typeof hashMode === 'string';

  if (this.hashMode) {
    this[hashMode] = this._finalOrDigest;
  } else {
    this.final = this._finalOrDigest;
  }

  if (this._final) {
    this.__final = this._final;
    this._final = null;
  }

  this._decoder = null;
  this._encoding = null;
}

inherits(CipherBase, Transform);

CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
  if (typeof data === 'string') {
    data = Buffer.from(data, inputEnc);
  }

  var outData = this._update(data);

  if (this.hashMode) return this;

  if (outputEnc) {
    outData = this._toString(outData, outputEnc);
  }

  return outData;
};

CipherBase.prototype.setAutoPadding = function () {};

CipherBase.prototype.getAuthTag = function () {
  throw new Error('trying to get auth tag in unsupported state');
};

CipherBase.prototype.setAuthTag = function () {
  throw new Error('trying to set auth tag in unsupported state');
};

CipherBase.prototype.setAAD = function () {
  throw new Error('trying to set aad in unsupported state');
};

CipherBase.prototype._transform = function (data, _, next) {
  var err;

  try {
    if (this.hashMode) {
      this._update(data);
    } else {
      this.push(this._update(data));
    }
  } catch (e) {
    err = e;
  } finally {
    next(err);
  }
};

CipherBase.prototype._flush = function (done) {
  var err;

  try {
    this.push(this.__final());
  } catch (e) {
    err = e;
  }

  done(err);
};

CipherBase.prototype._finalOrDigest = function (outputEnc) {
  var outData = this.__final() || Buffer.alloc(0);

  if (outputEnc) {
    outData = this._toString(outData, outputEnc, true);
  }

  return outData;
};

CipherBase.prototype._toString = function (value, enc, fin) {
  if (!this._decoder) {
    this._decoder = new StringDecoder(enc);
    this._encoding = enc;
  }

  if (this._encoding !== enc) throw new Error('can\'t switch encodings');

  var out = this._decoder.write(value);

  if (fin) {
    out += this._decoder.end();
  }

  return out;
};

module.exports = CipherBase;

/***/ }),

/***/ "./node_modules/core-util-is/lib/util.js":
/*!***********************************************!*\
  !*** ./node_modules/core-util-is/lib/util.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// 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);
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/create-ecdh/browser.js":
/*!*********************************************!*\
  !*** ./node_modules/create-ecdh/browser.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var elliptic = __webpack_require__(/*! elliptic */ "./node_modules/elliptic/lib/elliptic.js");

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

module.exports = function createECDH(curve) {
  return new ECDH(curve);
};

var aliases = {
  secp256k1: {
    name: 'secp256k1',
    byteLength: 32
  },
  secp224r1: {
    name: 'p224',
    byteLength: 28
  },
  prime256v1: {
    name: 'p256',
    byteLength: 32
  },
  prime192v1: {
    name: 'p192',
    byteLength: 24
  },
  ed25519: {
    name: 'ed25519',
    byteLength: 32
  },
  secp384r1: {
    name: 'p384',
    byteLength: 48
  },
  secp521r1: {
    name: 'p521',
    byteLength: 66
  }
};
aliases.p224 = aliases.secp224r1;
aliases.p256 = aliases.secp256r1 = aliases.prime256v1;
aliases.p192 = aliases.secp192r1 = aliases.prime192v1;
aliases.p384 = aliases.secp384r1;
aliases.p521 = aliases.secp521r1;

function ECDH(curve) {
  this.curveType = aliases[curve];

  if (!this.curveType) {
    this.curveType = {
      name: curve
    };
  }

  this.curve = new elliptic.ec(this.curveType.name); // eslint-disable-line new-cap

  this.keys = void 0;
}

ECDH.prototype.generateKeys = function (enc, format) {
  this.keys = this.curve.genKeyPair();
  return this.getPublicKey(enc, format);
};

ECDH.prototype.computeSecret = function (other, inenc, enc) {
  inenc = inenc || 'utf8';

  if (!Buffer.isBuffer(other)) {
    other = new Buffer(other, inenc);
  }

  var otherPub = this.curve.keyFromPublic(other).getPublic();
  var out = otherPub.mul(this.keys.getPrivate()).getX();
  return formatReturnValue(out, enc, this.curveType.byteLength);
};

ECDH.prototype.getPublicKey = function (enc, format) {
  var key = this.keys.getPublic(format === 'compressed', true);

  if (format === 'hybrid') {
    if (key[key.length - 1] % 2) {
      key[0] = 7;
    } else {
      key[0] = 6;
    }
  }

  return formatReturnValue(key, enc);
};

ECDH.prototype.getPrivateKey = function (enc) {
  return formatReturnValue(this.keys.getPrivate(), enc);
};

ECDH.prototype.setPublicKey = function (pub, enc) {
  enc = enc || 'utf8';

  if (!Buffer.isBuffer(pub)) {
    pub = new Buffer(pub, enc);
  }

  this.keys._importPublic(pub);

  return this;
};

ECDH.prototype.setPrivateKey = function (priv, enc) {
  enc = enc || 'utf8';

  if (!Buffer.isBuffer(priv)) {
    priv = new Buffer(priv, enc);
  }

  var _priv = new BN(priv);

  _priv = _priv.toString(16);
  this.keys = this.curve.genKeyPair();

  this.keys._importPrivate(_priv);

  return this;
};

function formatReturnValue(bn, enc, len) {
  if (!Array.isArray(bn)) {
    bn = bn.toArray();
  }

  var buf = new Buffer(bn);

  if (len && buf.length < len) {
    var zeros = new Buffer(len - buf.length);
    zeros.fill(0);
    buf = Buffer.concat([zeros, buf]);
  }

  if (!enc) {
    return buf;
  } else {
    return buf.toString(enc);
  }
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/create-hash/browser.js":
/*!*********************************************!*\
  !*** ./node_modules/create-hash/browser.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var MD5 = __webpack_require__(/*! md5.js */ "./node_modules/md5.js/index.js");

var RIPEMD160 = __webpack_require__(/*! ripemd160 */ "./node_modules/ripemd160/index.js");

var sha = __webpack_require__(/*! sha.js */ "./node_modules/sha.js/index.js");

var Base = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

function Hash(hash) {
  Base.call(this, 'digest');
  this._hash = hash;
}

inherits(Hash, Base);

Hash.prototype._update = function (data) {
  this._hash.update(data);
};

Hash.prototype._final = function () {
  return this._hash.digest();
};

module.exports = function createHash(alg) {
  alg = alg.toLowerCase();
  if (alg === 'md5') return new MD5();
  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160();
  return new Hash(sha(alg));
};

/***/ }),

/***/ "./node_modules/create-hash/md5.js":
/*!*****************************************!*\
  !*** ./node_modules/create-hash/md5.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var MD5 = __webpack_require__(/*! md5.js */ "./node_modules/md5.js/index.js");

module.exports = function (buffer) {
  return new MD5().update(buffer).digest();
};

/***/ }),

/***/ "./node_modules/create-hmac/browser.js":
/*!*********************************************!*\
  !*** ./node_modules/create-hmac/browser.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Legacy = __webpack_require__(/*! ./legacy */ "./node_modules/create-hmac/legacy.js");

var Base = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var md5 = __webpack_require__(/*! create-hash/md5 */ "./node_modules/create-hash/md5.js");

var RIPEMD160 = __webpack_require__(/*! ripemd160 */ "./node_modules/ripemd160/index.js");

var sha = __webpack_require__(/*! sha.js */ "./node_modules/sha.js/index.js");

var ZEROS = Buffer.alloc(128);

function Hmac(alg, key) {
  Base.call(this, 'digest');

  if (typeof key === 'string') {
    key = Buffer.from(key);
  }

  var blocksize = alg === 'sha512' || alg === 'sha384' ? 128 : 64;
  this._alg = alg;
  this._key = key;

  if (key.length > blocksize) {
    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
    key = hash.update(key).digest();
  } else if (key.length < blocksize) {
    key = Buffer.concat([key, ZEROS], blocksize);
  }

  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
  var opad = this._opad = Buffer.allocUnsafe(blocksize);

  for (var i = 0; i < blocksize; i++) {
    ipad[i] = key[i] ^ 0x36;
    opad[i] = key[i] ^ 0x5C;
  }

  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);

  this._hash.update(ipad);
}

inherits(Hmac, Base);

Hmac.prototype._update = function (data) {
  this._hash.update(data);
};

Hmac.prototype._final = function () {
  var h = this._hash.digest();

  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg);
  return hash.update(this._opad).update(h).digest();
};

module.exports = function createHmac(alg, key) {
  alg = alg.toLowerCase();

  if (alg === 'rmd160' || alg === 'ripemd160') {
    return new Hmac('rmd160', key);
  }

  if (alg === 'md5') {
    return new Legacy(md5, key);
  }

  return new Hmac(alg, key);
};

/***/ }),

/***/ "./node_modules/create-hmac/legacy.js":
/*!********************************************!*\
  !*** ./node_modules/create-hmac/legacy.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var Base = __webpack_require__(/*! cipher-base */ "./node_modules/cipher-base/index.js");

var ZEROS = Buffer.alloc(128);
var blocksize = 64;

function Hmac(alg, key) {
  Base.call(this, 'digest');

  if (typeof key === 'string') {
    key = Buffer.from(key);
  }

  this._alg = alg;
  this._key = key;

  if (key.length > blocksize) {
    key = alg(key);
  } else if (key.length < blocksize) {
    key = Buffer.concat([key, ZEROS], blocksize);
  }

  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
  var opad = this._opad = Buffer.allocUnsafe(blocksize);

  for (var i = 0; i < blocksize; i++) {
    ipad[i] = key[i] ^ 0x36;
    opad[i] = key[i] ^ 0x5C;
  }

  this._hash = [ipad];
}

inherits(Hmac, Base);

Hmac.prototype._update = function (data) {
  this._hash.push(data);
};

Hmac.prototype._final = function () {
  var h = this._alg(Buffer.concat(this._hash));

  return this._alg(Buffer.concat([this._opad, h]));
};

module.exports = Hmac;

/***/ }),

/***/ "./node_modules/crypto-browserify/index.js":
/*!*************************************************!*\
  !*** ./node_modules/crypto-browserify/index.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");
exports.createHash = exports.Hash = __webpack_require__(/*! create-hash */ "./node_modules/create-hash/browser.js");
exports.createHmac = exports.Hmac = __webpack_require__(/*! create-hmac */ "./node_modules/create-hmac/browser.js");

var algos = __webpack_require__(/*! browserify-sign/algos */ "./node_modules/browserify-sign/algos.js");

var algoKeys = Object.keys(algos);
var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys);

exports.getHashes = function () {
  return hashes;
};

var p = __webpack_require__(/*! pbkdf2 */ "./node_modules/pbkdf2/browser.js");

exports.pbkdf2 = p.pbkdf2;
exports.pbkdf2Sync = p.pbkdf2Sync;

var aes = __webpack_require__(/*! browserify-cipher */ "./node_modules/browserify-cipher/browser.js");

exports.Cipher = aes.Cipher;
exports.createCipher = aes.createCipher;
exports.Cipheriv = aes.Cipheriv;
exports.createCipheriv = aes.createCipheriv;
exports.Decipher = aes.Decipher;
exports.createDecipher = aes.createDecipher;
exports.Decipheriv = aes.Decipheriv;
exports.createDecipheriv = aes.createDecipheriv;
exports.getCiphers = aes.getCiphers;
exports.listCiphers = aes.listCiphers;

var dh = __webpack_require__(/*! diffie-hellman */ "./node_modules/diffie-hellman/browser.js");

exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
exports.getDiffieHellman = dh.getDiffieHellman;
exports.createDiffieHellman = dh.createDiffieHellman;
exports.DiffieHellman = dh.DiffieHellman;

var sign = __webpack_require__(/*! browserify-sign */ "./node_modules/browserify-sign/browser/index.js");

exports.createSign = sign.createSign;
exports.Sign = sign.Sign;
exports.createVerify = sign.createVerify;
exports.Verify = sign.Verify;
exports.createECDH = __webpack_require__(/*! create-ecdh */ "./node_modules/create-ecdh/browser.js");

var publicEncrypt = __webpack_require__(/*! public-encrypt */ "./node_modules/public-encrypt/browser.js");

exports.publicEncrypt = publicEncrypt.publicEncrypt;
exports.privateEncrypt = publicEncrypt.privateEncrypt;
exports.publicDecrypt = publicEncrypt.publicDecrypt;
exports.privateDecrypt = publicEncrypt.privateDecrypt; // the least I can do is make error messages for the rest of the node.js/crypto api.
// ;[
//   'createCredentials'
// ].forEach(function (name) {
//   exports[name] = function () {
//     throw new Error([
//       'sorry, ' + name + ' is not implemented yet',
//       'we accept pull requests',
//       'https://github.com/crypto-browserify/crypto-browserify'
//     ].join('\n'))
//   }
// })

var rf = __webpack_require__(/*! randomfill */ "./node_modules/randomfill/browser.js");

exports.randomFill = rf.randomFill;
exports.randomFillSync = rf.randomFillSync;

exports.createCredentials = function () {
  throw new Error(['sorry, createCredentials is not implemented yet', 'we accept pull requests', 'https://github.com/crypto-browserify/crypto-browserify'].join('\n'));
};

exports.constants = {
  'DH_CHECK_P_NOT_SAFE_PRIME': 2,
  'DH_CHECK_P_NOT_PRIME': 1,
  'DH_UNABLE_TO_CHECK_GENERATOR': 4,
  'DH_NOT_SUITABLE_GENERATOR': 8,
  'NPN_ENABLED': 1,
  'ALPN_ENABLED': 1,
  'RSA_PKCS1_PADDING': 1,
  'RSA_SSLV23_PADDING': 2,
  'RSA_NO_PADDING': 3,
  'RSA_PKCS1_OAEP_PADDING': 4,
  'RSA_X931_PADDING': 5,
  'RSA_PKCS1_PSS_PADDING': 6,
  'POINT_CONVERSION_COMPRESSED': 2,
  'POINT_CONVERSION_UNCOMPRESSED': 4,
  'POINT_CONVERSION_HYBRID': 6
};

/***/ }),

/***/ "./node_modules/des.js/lib/des.js":
/*!****************************************!*\
  !*** ./node_modules/des.js/lib/des.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.utils = __webpack_require__(/*! ./des/utils */ "./node_modules/des.js/lib/des/utils.js");
exports.Cipher = __webpack_require__(/*! ./des/cipher */ "./node_modules/des.js/lib/des/cipher.js");
exports.DES = __webpack_require__(/*! ./des/des */ "./node_modules/des.js/lib/des/des.js");
exports.CBC = __webpack_require__(/*! ./des/cbc */ "./node_modules/des.js/lib/des/cbc.js");
exports.EDE = __webpack_require__(/*! ./des/ede */ "./node_modules/des.js/lib/des/ede.js");

/***/ }),

/***/ "./node_modules/des.js/lib/des/cbc.js":
/*!********************************************!*\
  !*** ./node_modules/des.js/lib/des/cbc.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var proto = {};

function CBCState(iv) {
  assert.equal(iv.length, 8, 'Invalid IV length');
  this.iv = new Array(8);

  for (var i = 0; i < this.iv.length; i++) {
    this.iv[i] = iv[i];
  }
}

function instantiate(Base) {
  function CBC(options) {
    Base.call(this, options);

    this._cbcInit();
  }

  inherits(CBC, Base);
  var keys = Object.keys(proto);

  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    CBC.prototype[key] = proto[key];
  }

  CBC.create = function create(options) {
    return new CBC(options);
  };

  return CBC;
}

exports.instantiate = instantiate;

proto._cbcInit = function _cbcInit() {
  var state = new CBCState(this.options.iv);
  this._cbcState = state;
};

proto._update = function _update(inp, inOff, out, outOff) {
  var state = this._cbcState;
  var superProto = this.constructor.super_.prototype;
  var iv = state.iv;

  if (this.type === 'encrypt') {
    for (var i = 0; i < this.blockSize; i++) {
      iv[i] ^= inp[inOff + i];
    }

    superProto._update.call(this, iv, 0, out, outOff);

    for (var i = 0; i < this.blockSize; i++) {
      iv[i] = out[outOff + i];
    }
  } else {
    superProto._update.call(this, inp, inOff, out, outOff);

    for (var i = 0; i < this.blockSize; i++) {
      out[outOff + i] ^= iv[i];
    }

    for (var i = 0; i < this.blockSize; i++) {
      iv[i] = inp[inOff + i];
    }
  }
};

/***/ }),

/***/ "./node_modules/des.js/lib/des/cipher.js":
/*!***********************************************!*\
  !*** ./node_modules/des.js/lib/des/cipher.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

function Cipher(options) {
  this.options = options;
  this.type = this.options.type;
  this.blockSize = 8;

  this._init();

  this.buffer = new Array(this.blockSize);
  this.bufferOff = 0;
}

module.exports = Cipher;

Cipher.prototype._init = function _init() {// Might be overrided
};

Cipher.prototype.update = function update(data) {
  if (data.length === 0) return [];
  if (this.type === 'decrypt') return this._updateDecrypt(data);else return this._updateEncrypt(data);
};

Cipher.prototype._buffer = function _buffer(data, off) {
  // Append data to buffer
  var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);

  for (var i = 0; i < min; i++) {
    this.buffer[this.bufferOff + i] = data[off + i];
  }

  this.bufferOff += min; // Shift next

  return min;
};

Cipher.prototype._flushBuffer = function _flushBuffer(out, off) {
  this._update(this.buffer, 0, out, off);

  this.bufferOff = 0;
  return this.blockSize;
};

Cipher.prototype._updateEncrypt = function _updateEncrypt(data) {
  var inputOff = 0;
  var outputOff = 0;
  var count = (this.bufferOff + data.length) / this.blockSize | 0;
  var out = new Array(count * this.blockSize);

  if (this.bufferOff !== 0) {
    inputOff += this._buffer(data, inputOff);
    if (this.bufferOff === this.buffer.length) outputOff += this._flushBuffer(out, outputOff);
  } // Write blocks


  var max = data.length - (data.length - inputOff) % this.blockSize;

  for (; inputOff < max; inputOff += this.blockSize) {
    this._update(data, inputOff, out, outputOff);

    outputOff += this.blockSize;
  } // Queue rest


  for (; inputOff < data.length; inputOff++, this.bufferOff++) {
    this.buffer[this.bufferOff] = data[inputOff];
  }

  return out;
};

Cipher.prototype._updateDecrypt = function _updateDecrypt(data) {
  var inputOff = 0;
  var outputOff = 0;
  var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;
  var out = new Array(count * this.blockSize); // TODO(indutny): optimize it, this is far from optimal

  for (; count > 0; count--) {
    inputOff += this._buffer(data, inputOff);
    outputOff += this._flushBuffer(out, outputOff);
  } // Buffer rest of the input


  inputOff += this._buffer(data, inputOff);
  return out;
};

Cipher.prototype.final = function final(buffer) {
  var first;
  if (buffer) first = this.update(buffer);
  var last;
  if (this.type === 'encrypt') last = this._finalEncrypt();else last = this._finalDecrypt();
  if (first) return first.concat(last);else return last;
};

Cipher.prototype._pad = function _pad(buffer, off) {
  if (off === 0) return false;

  while (off < buffer.length) {
    buffer[off++] = 0;
  }

  return true;
};

Cipher.prototype._finalEncrypt = function _finalEncrypt() {
  if (!this._pad(this.buffer, this.bufferOff)) return [];
  var out = new Array(this.blockSize);

  this._update(this.buffer, 0, out, 0);

  return out;
};

Cipher.prototype._unpad = function _unpad(buffer) {
  return buffer;
};

Cipher.prototype._finalDecrypt = function _finalDecrypt() {
  assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');
  var out = new Array(this.blockSize);

  this._flushBuffer(out, 0);

  return this._unpad(out);
};

/***/ }),

/***/ "./node_modules/des.js/lib/des/des.js":
/*!********************************************!*\
  !*** ./node_modules/des.js/lib/des/des.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var utils = __webpack_require__(/*! ./utils */ "./node_modules/des.js/lib/des/utils.js");

var Cipher = __webpack_require__(/*! ./cipher */ "./node_modules/des.js/lib/des/cipher.js");

function DESState() {
  this.tmp = new Array(2);
  this.keys = null;
}

function DES(options) {
  Cipher.call(this, options);
  var state = new DESState();
  this._desState = state;
  this.deriveKeys(state, options.key);
}

inherits(DES, Cipher);
module.exports = DES;

DES.create = function create(options) {
  return new DES(options);
};

var shiftTable = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];

DES.prototype.deriveKeys = function deriveKeys(state, key) {
  state.keys = new Array(16 * 2);
  assert.equal(key.length, this.blockSize, 'Invalid key length');
  var kL = utils.readUInt32BE(key, 0);
  var kR = utils.readUInt32BE(key, 4);
  utils.pc1(kL, kR, state.tmp, 0);
  kL = state.tmp[0];
  kR = state.tmp[1];

  for (var i = 0; i < state.keys.length; i += 2) {
    var shift = shiftTable[i >>> 1];
    kL = utils.r28shl(kL, shift);
    kR = utils.r28shl(kR, shift);
    utils.pc2(kL, kR, state.keys, i);
  }
};

DES.prototype._update = function _update(inp, inOff, out, outOff) {
  var state = this._desState;
  var l = utils.readUInt32BE(inp, inOff);
  var r = utils.readUInt32BE(inp, inOff + 4); // Initial Permutation

  utils.ip(l, r, state.tmp, 0);
  l = state.tmp[0];
  r = state.tmp[1];
  if (this.type === 'encrypt') this._encrypt(state, l, r, state.tmp, 0);else this._decrypt(state, l, r, state.tmp, 0);
  l = state.tmp[0];
  r = state.tmp[1];
  utils.writeUInt32BE(out, l, outOff);
  utils.writeUInt32BE(out, r, outOff + 4);
};

DES.prototype._pad = function _pad(buffer, off) {
  var value = buffer.length - off;

  for (var i = off; i < buffer.length; i++) {
    buffer[i] = value;
  }

  return true;
};

DES.prototype._unpad = function _unpad(buffer) {
  var pad = buffer[buffer.length - 1];

  for (var i = buffer.length - pad; i < buffer.length; i++) {
    assert.equal(buffer[i], pad);
  }

  return buffer.slice(0, buffer.length - pad);
};

DES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {
  var l = lStart;
  var r = rStart; // Apply f() x16 times

  for (var i = 0; i < state.keys.length; i += 2) {
    var keyL = state.keys[i];
    var keyR = state.keys[i + 1]; // f(r, k)

    utils.expand(r, state.tmp, 0);
    keyL ^= state.tmp[0];
    keyR ^= state.tmp[1];
    var s = utils.substitute(keyL, keyR);
    var f = utils.permute(s);
    var t = r;
    r = (l ^ f) >>> 0;
    l = t;
  } // Reverse Initial Permutation


  utils.rip(r, l, out, off);
};

DES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {
  var l = rStart;
  var r = lStart; // Apply f() x16 times

  for (var i = state.keys.length - 2; i >= 0; i -= 2) {
    var keyL = state.keys[i];
    var keyR = state.keys[i + 1]; // f(r, k)

    utils.expand(l, state.tmp, 0);
    keyL ^= state.tmp[0];
    keyR ^= state.tmp[1];
    var s = utils.substitute(keyL, keyR);
    var f = utils.permute(s);
    var t = l;
    l = (r ^ f) >>> 0;
    r = t;
  } // Reverse Initial Permutation


  utils.rip(l, r, out, off);
};

/***/ }),

/***/ "./node_modules/des.js/lib/des/ede.js":
/*!********************************************!*\
  !*** ./node_modules/des.js/lib/des/ede.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Cipher = __webpack_require__(/*! ./cipher */ "./node_modules/des.js/lib/des/cipher.js");

var DES = __webpack_require__(/*! ./des */ "./node_modules/des.js/lib/des/des.js");

function EDEState(type, key) {
  assert.equal(key.length, 24, 'Invalid key length');
  var k1 = key.slice(0, 8);
  var k2 = key.slice(8, 16);
  var k3 = key.slice(16, 24);

  if (type === 'encrypt') {
    this.ciphers = [DES.create({
      type: 'encrypt',
      key: k1
    }), DES.create({
      type: 'decrypt',
      key: k2
    }), DES.create({
      type: 'encrypt',
      key: k3
    })];
  } else {
    this.ciphers = [DES.create({
      type: 'decrypt',
      key: k3
    }), DES.create({
      type: 'encrypt',
      key: k2
    }), DES.create({
      type: 'decrypt',
      key: k1
    })];
  }
}

function EDE(options) {
  Cipher.call(this, options);
  var state = new EDEState(this.type, this.options.key);
  this._edeState = state;
}

inherits(EDE, Cipher);
module.exports = EDE;

EDE.create = function create(options) {
  return new EDE(options);
};

EDE.prototype._update = function _update(inp, inOff, out, outOff) {
  var state = this._edeState;

  state.ciphers[0]._update(inp, inOff, out, outOff);

  state.ciphers[1]._update(out, outOff, out, outOff);

  state.ciphers[2]._update(out, outOff, out, outOff);
};

EDE.prototype._pad = DES.prototype._pad;
EDE.prototype._unpad = DES.prototype._unpad;

/***/ }),

/***/ "./node_modules/des.js/lib/des/utils.js":
/*!**********************************************!*\
  !*** ./node_modules/des.js/lib/des/utils.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.readUInt32BE = function readUInt32BE(bytes, off) {
  var res = bytes[0 + off] << 24 | bytes[1 + off] << 16 | bytes[2 + off] << 8 | bytes[3 + off];
  return res >>> 0;
};

exports.writeUInt32BE = function writeUInt32BE(bytes, value, off) {
  bytes[0 + off] = value >>> 24;
  bytes[1 + off] = value >>> 16 & 0xff;
  bytes[2 + off] = value >>> 8 & 0xff;
  bytes[3 + off] = value & 0xff;
};

exports.ip = function ip(inL, inR, out, off) {
  var outL = 0;
  var outR = 0;

  for (var i = 6; i >= 0; i -= 2) {
    for (var j = 0; j <= 24; j += 8) {
      outL <<= 1;
      outL |= inR >>> j + i & 1;
    }

    for (var j = 0; j <= 24; j += 8) {
      outL <<= 1;
      outL |= inL >>> j + i & 1;
    }
  }

  for (var i = 6; i >= 0; i -= 2) {
    for (var j = 1; j <= 25; j += 8) {
      outR <<= 1;
      outR |= inR >>> j + i & 1;
    }

    for (var j = 1; j <= 25; j += 8) {
      outR <<= 1;
      outR |= inL >>> j + i & 1;
    }
  }

  out[off + 0] = outL >>> 0;
  out[off + 1] = outR >>> 0;
};

exports.rip = function rip(inL, inR, out, off) {
  var outL = 0;
  var outR = 0;

  for (var i = 0; i < 4; i++) {
    for (var j = 24; j >= 0; j -= 8) {
      outL <<= 1;
      outL |= inR >>> j + i & 1;
      outL <<= 1;
      outL |= inL >>> j + i & 1;
    }
  }

  for (var i = 4; i < 8; i++) {
    for (var j = 24; j >= 0; j -= 8) {
      outR <<= 1;
      outR |= inR >>> j + i & 1;
      outR <<= 1;
      outR |= inL >>> j + i & 1;
    }
  }

  out[off + 0] = outL >>> 0;
  out[off + 1] = outR >>> 0;
};

exports.pc1 = function pc1(inL, inR, out, off) {
  var outL = 0;
  var outR = 0; // 7, 15, 23, 31, 39, 47, 55, 63
  // 6, 14, 22, 30, 39, 47, 55, 63
  // 5, 13, 21, 29, 39, 47, 55, 63
  // 4, 12, 20, 28

  for (var i = 7; i >= 5; i--) {
    for (var j = 0; j <= 24; j += 8) {
      outL <<= 1;
      outL |= inR >> j + i & 1;
    }

    for (var j = 0; j <= 24; j += 8) {
      outL <<= 1;
      outL |= inL >> j + i & 1;
    }
  }

  for (var j = 0; j <= 24; j += 8) {
    outL <<= 1;
    outL |= inR >> j + i & 1;
  } // 1, 9, 17, 25, 33, 41, 49, 57
  // 2, 10, 18, 26, 34, 42, 50, 58
  // 3, 11, 19, 27, 35, 43, 51, 59
  // 36, 44, 52, 60


  for (var i = 1; i <= 3; i++) {
    for (var j = 0; j <= 24; j += 8) {
      outR <<= 1;
      outR |= inR >> j + i & 1;
    }

    for (var j = 0; j <= 24; j += 8) {
      outR <<= 1;
      outR |= inL >> j + i & 1;
    }
  }

  for (var j = 0; j <= 24; j += 8) {
    outR <<= 1;
    outR |= inL >> j + i & 1;
  }

  out[off + 0] = outL >>> 0;
  out[off + 1] = outR >>> 0;
};

exports.r28shl = function r28shl(num, shift) {
  return num << shift & 0xfffffff | num >>> 28 - shift;
};

var pc2table = [// inL => outL
14, 11, 17, 4, 27, 23, 25, 0, 13, 22, 7, 18, 5, 9, 16, 24, 2, 20, 12, 21, 1, 8, 15, 26, // inR => outR
15, 4, 25, 19, 9, 1, 26, 16, 5, 11, 23, 8, 12, 7, 17, 0, 22, 3, 10, 14, 6, 20, 27, 24];

exports.pc2 = function pc2(inL, inR, out, off) {
  var outL = 0;
  var outR = 0;
  var len = pc2table.length >>> 1;

  for (var i = 0; i < len; i++) {
    outL <<= 1;
    outL |= inL >>> pc2table[i] & 0x1;
  }

  for (var i = len; i < pc2table.length; i++) {
    outR <<= 1;
    outR |= inR >>> pc2table[i] & 0x1;
  }

  out[off + 0] = outL >>> 0;
  out[off + 1] = outR >>> 0;
};

exports.expand = function expand(r, out, off) {
  var outL = 0;
  var outR = 0;
  outL = (r & 1) << 5 | r >>> 27;

  for (var i = 23; i >= 15; i -= 4) {
    outL <<= 6;
    outL |= r >>> i & 0x3f;
  }

  for (var i = 11; i >= 3; i -= 4) {
    outR |= r >>> i & 0x3f;
    outR <<= 6;
  }

  outR |= (r & 0x1f) << 1 | r >>> 31;
  out[off + 0] = outL >>> 0;
  out[off + 1] = outR >>> 0;
};

var sTable = [14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1, 3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8, 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7, 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13, 15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14, 9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5, 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2, 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9, 10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10, 1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1, 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7, 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12, 7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3, 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9, 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8, 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14, 2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1, 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6, 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13, 15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3, 12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5, 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8, 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10, 7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13, 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10, 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6, 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7, 10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12, 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4, 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2, 7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13, 0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11];

exports.substitute = function substitute(inL, inR) {
  var out = 0;

  for (var i = 0; i < 4; i++) {
    var b = inL >>> 18 - i * 6 & 0x3f;
    var sb = sTable[i * 0x40 + b];
    out <<= 4;
    out |= sb;
  }

  for (var i = 0; i < 4; i++) {
    var b = inR >>> 18 - i * 6 & 0x3f;
    var sb = sTable[4 * 0x40 + i * 0x40 + b];
    out <<= 4;
    out |= sb;
  }

  return out >>> 0;
};

var permuteTable = [16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22, 30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7];

exports.permute = function permute(num) {
  var out = 0;

  for (var i = 0; i < permuteTable.length; i++) {
    out <<= 1;
    out |= num >>> permuteTable[i] & 0x1;
  }

  return out >>> 0;
};

exports.padSplit = function padSplit(num, size, group) {
  var str = num.toString(2);

  while (str.length < size) {
    str = '0' + str;
  }

  var out = [];

  for (var i = 0; i < size; i += group) {
    out.push(str.slice(i, i + group));
  }

  return out.join(' ');
};

/***/ }),

/***/ "./node_modules/diffie-hellman/browser.js":
/*!************************************************!*\
  !*** ./node_modules/diffie-hellman/browser.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var generatePrime = __webpack_require__(/*! ./lib/generatePrime */ "./node_modules/diffie-hellman/lib/generatePrime.js");

var primes = __webpack_require__(/*! ./lib/primes.json */ "./node_modules/diffie-hellman/lib/primes.json");

var DH = __webpack_require__(/*! ./lib/dh */ "./node_modules/diffie-hellman/lib/dh.js");

function getDiffieHellman(mod) {
  var prime = new Buffer(primes[mod].prime, 'hex');
  var gen = new Buffer(primes[mod].gen, 'hex');
  return new DH(prime, gen);
}

var ENCODINGS = {
  'binary': true,
  'hex': true,
  'base64': true
};

function createDiffieHellman(prime, enc, generator, genc) {
  if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {
    return createDiffieHellman(prime, 'binary', enc, generator);
  }

  enc = enc || 'binary';
  genc = genc || 'binary';
  generator = generator || new Buffer([2]);

  if (!Buffer.isBuffer(generator)) {
    generator = new Buffer(generator, genc);
  }

  if (typeof prime === 'number') {
    return new DH(generatePrime(prime, generator), generator, true);
  }

  if (!Buffer.isBuffer(prime)) {
    prime = new Buffer(prime, enc);
  }

  return new DH(prime, generator, true);
}

exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman;
exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/diffie-hellman/lib/dh.js":
/*!***********************************************!*\
  !*** ./node_modules/diffie-hellman/lib/dh.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var MillerRabin = __webpack_require__(/*! miller-rabin */ "./node_modules/miller-rabin/lib/mr.js");

var millerRabin = new MillerRabin();
var TWENTYFOUR = new BN(24);
var ELEVEN = new BN(11);
var TEN = new BN(10);
var THREE = new BN(3);
var SEVEN = new BN(7);

var primes = __webpack_require__(/*! ./generatePrime */ "./node_modules/diffie-hellman/lib/generatePrime.js");

var randomBytes = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");

module.exports = DH;

function setPublicKey(pub, enc) {
  enc = enc || 'utf8';

  if (!Buffer.isBuffer(pub)) {
    pub = new Buffer(pub, enc);
  }

  this._pub = new BN(pub);
  return this;
}

function setPrivateKey(priv, enc) {
  enc = enc || 'utf8';

  if (!Buffer.isBuffer(priv)) {
    priv = new Buffer(priv, enc);
  }

  this._priv = new BN(priv);
  return this;
}

var primeCache = {};

function checkPrime(prime, generator) {
  var gen = generator.toString('hex');
  var hex = [gen, prime.toString(16)].join('_');

  if (hex in primeCache) {
    return primeCache[hex];
  }

  var error = 0;

  if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) {
    //not a prime so +1
    error += 1;

    if (gen === '02' || gen === '05') {
      // we'd be able to check the generator
      // it would fail so +8
      error += 8;
    } else {
      //we wouldn't be able to test the generator
      // so +4
      error += 4;
    }

    primeCache[hex] = error;
    return error;
  }

  if (!millerRabin.test(prime.shrn(1))) {
    //not a safe prime
    error += 2;
  }

  var rem;

  switch (gen) {
    case '02':
      if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {
        // unsuidable generator
        error += 8;
      }

      break;

    case '05':
      rem = prime.mod(TEN);

      if (rem.cmp(THREE) && rem.cmp(SEVEN)) {
        // prime mod 10 needs to equal 3 or 7
        error += 8;
      }

      break;

    default:
      error += 4;
  }

  primeCache[hex] = error;
  return error;
}

function DH(prime, generator, malleable) {
  this.setGenerator(generator);
  this.__prime = new BN(prime);
  this._prime = BN.mont(this.__prime);
  this._primeLen = prime.length;
  this._pub = undefined;
  this._priv = undefined;
  this._primeCode = undefined;

  if (malleable) {
    this.setPublicKey = setPublicKey;
    this.setPrivateKey = setPrivateKey;
  } else {
    this._primeCode = 8;
  }
}

Object.defineProperty(DH.prototype, 'verifyError', {
  enumerable: true,
  get: function get() {
    if (typeof this._primeCode !== 'number') {
      this._primeCode = checkPrime(this.__prime, this.__gen);
    }

    return this._primeCode;
  }
});

DH.prototype.generateKeys = function () {
  if (!this._priv) {
    this._priv = new BN(randomBytes(this._primeLen));
  }

  this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();
  return this.getPublicKey();
};

DH.prototype.computeSecret = function (other) {
  other = new BN(other);
  other = other.toRed(this._prime);
  var secret = other.redPow(this._priv).fromRed();
  var out = new Buffer(secret.toArray());
  var prime = this.getPrime();

  if (out.length < prime.length) {
    var front = new Buffer(prime.length - out.length);
    front.fill(0);
    out = Buffer.concat([front, out]);
  }

  return out;
};

DH.prototype.getPublicKey = function getPublicKey(enc) {
  return formatReturnValue(this._pub, enc);
};

DH.prototype.getPrivateKey = function getPrivateKey(enc) {
  return formatReturnValue(this._priv, enc);
};

DH.prototype.getPrime = function (enc) {
  return formatReturnValue(this.__prime, enc);
};

DH.prototype.getGenerator = function (enc) {
  return formatReturnValue(this._gen, enc);
};

DH.prototype.setGenerator = function (gen, enc) {
  enc = enc || 'utf8';

  if (!Buffer.isBuffer(gen)) {
    gen = new Buffer(gen, enc);
  }

  this.__gen = gen;
  this._gen = new BN(gen);
  return this;
};

function formatReturnValue(bn, enc) {
  var buf = new Buffer(bn.toArray());

  if (!enc) {
    return buf;
  } else {
    return buf.toString(enc);
  }
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/diffie-hellman/lib/generatePrime.js":
/*!**********************************************************!*\
  !*** ./node_modules/diffie-hellman/lib/generatePrime.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var randomBytes = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");

module.exports = findPrime;
findPrime.simpleSieve = simpleSieve;
findPrime.fermatTest = fermatTest;

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var TWENTYFOUR = new BN(24);

var MillerRabin = __webpack_require__(/*! miller-rabin */ "./node_modules/miller-rabin/lib/mr.js");

var millerRabin = new MillerRabin();
var ONE = new BN(1);
var TWO = new BN(2);
var FIVE = new BN(5);
var SIXTEEN = new BN(16);
var EIGHT = new BN(8);
var TEN = new BN(10);
var THREE = new BN(3);
var SEVEN = new BN(7);
var ELEVEN = new BN(11);
var FOUR = new BN(4);
var TWELVE = new BN(12);
var primes = null;

function _getPrimes() {
  if (primes !== null) return primes;
  var limit = 0x100000;
  var res = [];
  res[0] = 2;

  for (var i = 1, k = 3; k < limit; k += 2) {
    var sqrt = Math.ceil(Math.sqrt(k));

    for (var j = 0; j < i && res[j] <= sqrt; j++) {
      if (k % res[j] === 0) break;
    }

    if (i !== j && res[j] <= sqrt) continue;
    res[i++] = k;
  }

  primes = res;
  return res;
}

function simpleSieve(p) {
  var primes = _getPrimes();

  for (var i = 0; i < primes.length; i++) {
    if (p.modn(primes[i]) === 0) {
      if (p.cmpn(primes[i]) === 0) {
        return true;
      } else {
        return false;
      }
    }
  }

  return true;
}

function fermatTest(p) {
  var red = BN.mont(p);
  return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;
}

function findPrime(bits, gen) {
  if (bits < 16) {
    // this is what openssl does
    if (gen === 2 || gen === 5) {
      return new BN([0x8c, 0x7b]);
    } else {
      return new BN([0x8c, 0x27]);
    }
  }

  gen = new BN(gen);
  var num, n2;

  while (true) {
    num = new BN(randomBytes(Math.ceil(bits / 8)));

    while (num.bitLength() > bits) {
      num.ishrn(1);
    }

    if (num.isEven()) {
      num.iadd(ONE);
    }

    if (!num.testn(1)) {
      num.iadd(TWO);
    }

    if (!gen.cmp(TWO)) {
      while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {
        num.iadd(FOUR);
      }
    } else if (!gen.cmp(FIVE)) {
      while (num.mod(TEN).cmp(THREE)) {
        num.iadd(FOUR);
      }
    }

    n2 = num.shrn(1);

    if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabin.test(n2) && millerRabin.test(num)) {
      return num;
    }
  }
}

/***/ }),

/***/ "./node_modules/diffie-hellman/lib/primes.json":
/*!*****************************************************!*\
  !*** ./node_modules/diffie-hellman/lib/primes.json ***!
  \*****************************************************/
/*! exports provided: modp1, modp2, modp5, modp14, modp15, modp16, modp17, modp18, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"modp1\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff\"},\"modp2\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff\"},\"modp5\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff\"},\"modp14\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff\"},\"modp15\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff\"},\"modp16\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff\"},\"modp17\":{\"gen\":\"02\",\"prime\":\"ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff\"},\"modp18\":{\"gen\":\"02\",\"prime\":\"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\"}}");

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic.js":
/*!***********************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var elliptic = exports;
elliptic.version = __webpack_require__(/*! ../package.json */ "./node_modules/elliptic/package.json").version;
elliptic.utils = __webpack_require__(/*! ./elliptic/utils */ "./node_modules/elliptic/lib/elliptic/utils.js");
elliptic.rand = __webpack_require__(/*! brorand */ "./node_modules/brorand/index.js");
elliptic.curve = __webpack_require__(/*! ./elliptic/curve */ "./node_modules/elliptic/lib/elliptic/curve/index.js");
elliptic.curves = __webpack_require__(/*! ./elliptic/curves */ "./node_modules/elliptic/lib/elliptic/curves.js"); // Protocols

elliptic.ec = __webpack_require__(/*! ./elliptic/ec */ "./node_modules/elliptic/lib/elliptic/ec/index.js");
elliptic.eddsa = __webpack_require__(/*! ./elliptic/eddsa */ "./node_modules/elliptic/lib/elliptic/eddsa/index.js");

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curve/base.js":
/*!**********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curve/base.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var getNAF = utils.getNAF;
var getJSF = utils.getJSF;
var assert = utils.assert;

function BaseCurve(type, conf) {
  this.type = type;
  this.p = new BN(conf.p, 16); // Use Montgomery, when there is no fast reduction for the prime

  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p); // Useful for many curves

  this.zero = new BN(0).toRed(this.red);
  this.one = new BN(1).toRed(this.red);
  this.two = new BN(2).toRed(this.red); // Curve configuration, optional

  this.n = conf.n && new BN(conf.n, 16);
  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed); // Temporary arrays

  this._wnafT1 = new Array(4);
  this._wnafT2 = new Array(4);
  this._wnafT3 = new Array(4);
  this._wnafT4 = new Array(4);
  this._bitLength = this.n ? this.n.bitLength() : 0; // Generalized Greg Maxwell's trick

  var adjustCount = this.n && this.p.div(this.n);

  if (!adjustCount || adjustCount.cmpn(100) > 0) {
    this.redN = null;
  } else {
    this._maxwellTrick = true;
    this.redN = this.n.toRed(this.red);
  }
}

module.exports = BaseCurve;

BaseCurve.prototype.point = function point() {
  throw new Error('Not implemented');
};

BaseCurve.prototype.validate = function validate() {
  throw new Error('Not implemented');
};

BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
  assert(p.precomputed);

  var doubles = p._getDoubles();

  var naf = getNAF(k, 1, this._bitLength);
  var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
  I /= 3; // Translate into more windowed form

  var repr = [];

  for (var j = 0; j < naf.length; j += doubles.step) {
    var nafW = 0;

    for (var k = j + doubles.step - 1; k >= j; k--) {
      nafW = (nafW << 1) + naf[k];
    }

    repr.push(nafW);
  }

  var a = this.jpoint(null, null, null);
  var b = this.jpoint(null, null, null);

  for (var i = I; i > 0; i--) {
    for (var j = 0; j < repr.length; j++) {
      var nafW = repr[j];
      if (nafW === i) b = b.mixedAdd(doubles.points[j]);else if (nafW === -i) b = b.mixedAdd(doubles.points[j].neg());
    }

    a = a.add(b);
  }

  return a.toP();
};

BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
  var w = 4; // Precompute window

  var nafPoints = p._getNAFPoints(w);

  w = nafPoints.wnd;
  var wnd = nafPoints.points; // Get NAF form

  var naf = getNAF(k, w, this._bitLength); // Add `this`*(N+1) for every w-NAF index

  var acc = this.jpoint(null, null, null);

  for (var i = naf.length - 1; i >= 0; i--) {
    // Count zeroes
    for (var k = 0; i >= 0 && naf[i] === 0; i--) {
      k++;
    }

    if (i >= 0) k++;
    acc = acc.dblp(k);
    if (i < 0) break;
    var z = naf[i];
    assert(z !== 0);

    if (p.type === 'affine') {
      // J +- P
      if (z > 0) acc = acc.mixedAdd(wnd[z - 1 >> 1]);else acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
    } else {
      // J +- J
      if (z > 0) acc = acc.add(wnd[z - 1 >> 1]);else acc = acc.add(wnd[-z - 1 >> 1].neg());
    }
  }

  return p.type === 'affine' ? acc.toP() : acc;
};

BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len, jacobianResult) {
  var wndWidth = this._wnafT1;
  var wnd = this._wnafT2;
  var naf = this._wnafT3; // Fill all arrays

  var max = 0;

  for (var i = 0; i < len; i++) {
    var p = points[i];

    var nafPoints = p._getNAFPoints(defW);

    wndWidth[i] = nafPoints.wnd;
    wnd[i] = nafPoints.points;
  } // Comb small window NAFs


  for (var i = len - 1; i >= 1; i -= 2) {
    var a = i - 1;
    var b = i;

    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
      naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);
      naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);
      max = Math.max(naf[a].length, max);
      max = Math.max(naf[b].length, max);
      continue;
    }

    var comb = [points[a],
    /* 1 */
    null,
    /* 3 */
    null,
    /* 5 */
    points[b]
    /* 7 */
    ]; // Try to avoid Projective points, if possible

    if (points[a].y.cmp(points[b].y) === 0) {
      comb[1] = points[a].add(points[b]);
      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
      comb[1] = points[a].toJ().mixedAdd(points[b]);
      comb[2] = points[a].add(points[b].neg());
    } else {
      comb[1] = points[a].toJ().mixedAdd(points[b]);
      comb[2] = points[a].toJ().mixedAdd(points[b].neg());
    }

    var index = [-3,
    /* -1 -1 */
    -1,
    /* -1 0 */
    -5,
    /* -1 1 */
    -7,
    /* 0 -1 */
    0,
    /* 0 0 */
    7,
    /* 0 1 */
    5,
    /* 1 -1 */
    1,
    /* 1 0 */
    3
    /* 1 1 */
    ];
    var jsf = getJSF(coeffs[a], coeffs[b]);
    max = Math.max(jsf[0].length, max);
    naf[a] = new Array(max);
    naf[b] = new Array(max);

    for (var j = 0; j < max; j++) {
      var ja = jsf[0][j] | 0;
      var jb = jsf[1][j] | 0;
      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
      naf[b][j] = 0;
      wnd[a] = comb;
    }
  }

  var acc = this.jpoint(null, null, null);
  var tmp = this._wnafT4;

  for (var i = max; i >= 0; i--) {
    var k = 0;

    while (i >= 0) {
      var zero = true;

      for (var j = 0; j < len; j++) {
        tmp[j] = naf[j][i] | 0;
        if (tmp[j] !== 0) zero = false;
      }

      if (!zero) break;
      k++;
      i--;
    }

    if (i >= 0) k++;
    acc = acc.dblp(k);
    if (i < 0) break;

    for (var j = 0; j < len; j++) {
      var z = tmp[j];
      var p;
      if (z === 0) continue;else if (z > 0) p = wnd[j][z - 1 >> 1];else if (z < 0) p = wnd[j][-z - 1 >> 1].neg();
      if (p.type === 'affine') acc = acc.mixedAdd(p);else acc = acc.add(p);
    }
  } // Zeroify references


  for (var i = 0; i < len; i++) {
    wnd[i] = null;
  }

  if (jacobianResult) return acc;else return acc.toP();
};

function BasePoint(curve, type) {
  this.curve = curve;
  this.type = type;
  this.precomputed = null;
}

BaseCurve.BasePoint = BasePoint;

BasePoint.prototype.eq = function eq()
/*other*/
{
  throw new Error('Not implemented');
};

BasePoint.prototype.validate = function validate() {
  return this.curve.validate(this);
};

BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
  bytes = utils.toArray(bytes, enc);
  var len = this.p.byteLength(); // uncompressed, hybrid-odd, hybrid-even

  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) && bytes.length - 1 === 2 * len) {
    if (bytes[0] === 0x06) assert(bytes[bytes.length - 1] % 2 === 0);else if (bytes[0] === 0x07) assert(bytes[bytes.length - 1] % 2 === 1);
    var res = this.point(bytes.slice(1, 1 + len), bytes.slice(1 + len, 1 + 2 * len));
    return res;
  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) && bytes.length - 1 === len) {
    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);
  }

  throw new Error('Unknown point format');
};

BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
  return this.encode(enc, true);
};

BasePoint.prototype._encode = function _encode(compact) {
  var len = this.curve.p.byteLength();
  var x = this.getX().toArray('be', len);
  if (compact) return [this.getY().isEven() ? 0x02 : 0x03].concat(x);
  return [0x04].concat(x, this.getY().toArray('be', len));
};

BasePoint.prototype.encode = function encode(enc, compact) {
  return utils.encode(this._encode(compact), enc);
};

BasePoint.prototype.precompute = function precompute(power) {
  if (this.precomputed) return this;
  var precomputed = {
    doubles: null,
    naf: null,
    beta: null
  };
  precomputed.naf = this._getNAFPoints(8);
  precomputed.doubles = this._getDoubles(4, power);
  precomputed.beta = this._getBeta();
  this.precomputed = precomputed;
  return this;
};

BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
  if (!this.precomputed) return false;
  var doubles = this.precomputed.doubles;
  if (!doubles) return false;
  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
};

BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
  if (this.precomputed && this.precomputed.doubles) return this.precomputed.doubles;
  var doubles = [this];
  var acc = this;

  for (var i = 0; i < power; i += step) {
    for (var j = 0; j < step; j++) {
      acc = acc.dbl();
    }

    doubles.push(acc);
  }

  return {
    step: step,
    points: doubles
  };
};

BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
  if (this.precomputed && this.precomputed.naf) return this.precomputed.naf;
  var res = [this];
  var max = (1 << wnd) - 1;
  var dbl = max === 1 ? null : this.dbl();

  for (var i = 1; i < max; i++) {
    res[i] = res[i - 1].add(dbl);
  }

  return {
    wnd: wnd,
    points: res
  };
};

BasePoint.prototype._getBeta = function _getBeta() {
  return null;
};

BasePoint.prototype.dblp = function dblp(k) {
  var r = this;

  for (var i = 0; i < k; i++) {
    r = r.dbl();
  }

  return r;
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curve/edwards.js":
/*!*************************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curve/edwards.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Base = __webpack_require__(/*! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js");

var assert = utils.assert;

function EdwardsCurve(conf) {
  // NOTE: Important as we are creating point in Base.call()
  this.twisted = (conf.a | 0) !== 1;
  this.mOneA = this.twisted && (conf.a | 0) === -1;
  this.extended = this.mOneA;
  Base.call(this, 'edwards', conf);
  this.a = new BN(conf.a, 16).umod(this.red.m);
  this.a = this.a.toRed(this.red);
  this.c = new BN(conf.c, 16).toRed(this.red);
  this.c2 = this.c.redSqr();
  this.d = new BN(conf.d, 16).toRed(this.red);
  this.dd = this.d.redAdd(this.d);
  assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);
  this.oneC = (conf.c | 0) === 1;
}

inherits(EdwardsCurve, Base);
module.exports = EdwardsCurve;

EdwardsCurve.prototype._mulA = function _mulA(num) {
  if (this.mOneA) return num.redNeg();else return this.a.redMul(num);
};

EdwardsCurve.prototype._mulC = function _mulC(num) {
  if (this.oneC) return num;else return this.c.redMul(num);
}; // Just for compatibility with Short curve


EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
  return this.point(x, y, z, t);
};

EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
  x = new BN(x, 16);
  if (!x.red) x = x.toRed(this.red);
  var x2 = x.redSqr();
  var rhs = this.c2.redSub(this.a.redMul(x2));
  var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
  var y2 = rhs.redMul(lhs.redInvm());
  var y = y2.redSqrt();
  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point');
  var isOdd = y.fromRed().isOdd();
  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
  return this.point(x, y);
};

EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
  y = new BN(y, 16);
  if (!y.red) y = y.toRed(this.red); // x^2 = (y^2 - c^2) / (c^2 d y^2 - a)

  var y2 = y.redSqr();
  var lhs = y2.redSub(this.c2);
  var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
  var x2 = lhs.redMul(rhs.redInvm());

  if (x2.cmp(this.zero) === 0) {
    if (odd) throw new Error('invalid point');else return this.point(this.zero, y);
  }

  var x = x2.redSqrt();
  if (x.redSqr().redSub(x2).cmp(this.zero) !== 0) throw new Error('invalid point');
  if (x.fromRed().isOdd() !== odd) x = x.redNeg();
  return this.point(x, y);
};

EdwardsCurve.prototype.validate = function validate(point) {
  if (point.isInfinity()) return true; // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)

  point.normalize();
  var x2 = point.x.redSqr();
  var y2 = point.y.redSqr();
  var lhs = x2.redMul(this.a).redAdd(y2);
  var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
  return lhs.cmp(rhs) === 0;
};

function Point(curve, x, y, z, t) {
  Base.BasePoint.call(this, curve, 'projective');

  if (x === null && y === null && z === null) {
    this.x = this.curve.zero;
    this.y = this.curve.one;
    this.z = this.curve.one;
    this.t = this.curve.zero;
    this.zOne = true;
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16);
    this.z = z ? new BN(z, 16) : this.curve.one;
    this.t = t && new BN(t, 16);
    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.y.red) this.y = this.y.toRed(this.curve.red);
    if (!this.z.red) this.z = this.z.toRed(this.curve.red);
    if (this.t && !this.t.red) this.t = this.t.toRed(this.curve.red);
    this.zOne = this.z === this.curve.one; // Use extended coordinates

    if (this.curve.extended && !this.t) {
      this.t = this.x.redMul(this.y);
      if (!this.zOne) this.t = this.t.redMul(this.z.redInvm());
    }
  }
}

inherits(Point, Base.BasePoint);

EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
  return Point.fromJSON(this, obj);
};

EdwardsCurve.prototype.point = function point(x, y, z, t) {
  return new Point(this, x, y, z, t);
};

Point.fromJSON = function fromJSON(curve, obj) {
  return new Point(curve, obj[0], obj[1], obj[2]);
};

Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';
};

Point.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
};

Point.prototype._extDbl = function _extDbl() {
  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
  //     #doubling-dbl-2008-hwcd
  // 4M + 4S
  // A = X1^2
  var a = this.x.redSqr(); // B = Y1^2

  var b = this.y.redSqr(); // C = 2 * Z1^2

  var c = this.z.redSqr();
  c = c.redIAdd(c); // D = a * A

  var d = this.curve._mulA(a); // E = (X1 + Y1)^2 - A - B


  var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b); // G = D + B

  var g = d.redAdd(b); // F = G - C

  var f = g.redSub(c); // H = D - B

  var h = d.redSub(b); // X3 = E * F

  var nx = e.redMul(f); // Y3 = G * H

  var ny = g.redMul(h); // T3 = E * H

  var nt = e.redMul(h); // Z3 = F * G

  var nz = f.redMul(g);
  return this.curve.point(nx, ny, nz, nt);
};

Point.prototype._projDbl = function _projDbl() {
  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
  //     #doubling-dbl-2008-bbjlp
  //     #doubling-dbl-2007-bl
  // and others
  // Generally 3M + 4S or 2M + 4S
  // B = (X1 + Y1)^2
  var b = this.x.redAdd(this.y).redSqr(); // C = X1^2

  var c = this.x.redSqr(); // D = Y1^2

  var d = this.y.redSqr();
  var nx;
  var ny;
  var nz;

  if (this.curve.twisted) {
    // E = a * C
    var e = this.curve._mulA(c); // F = E + D


    var f = e.redAdd(d);

    if (this.zOne) {
      // X3 = (B - C - D) * (F - 2)
      nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two)); // Y3 = F * (E - D)

      ny = f.redMul(e.redSub(d)); // Z3 = F^2 - 2 * F

      nz = f.redSqr().redSub(f).redSub(f);
    } else {
      // H = Z1^2
      var h = this.z.redSqr(); // J = F - 2 * H

      var j = f.redSub(h).redISub(h); // X3 = (B-C-D)*J

      nx = b.redSub(c).redISub(d).redMul(j); // Y3 = F * (E - D)

      ny = f.redMul(e.redSub(d)); // Z3 = F * J

      nz = f.redMul(j);
    }
  } else {
    // E = C + D
    var e = c.redAdd(d); // H = (c * Z1)^2

    var h = this.curve._mulC(this.z).redSqr(); // J = E - 2 * H


    var j = e.redSub(h).redSub(h); // X3 = c * (B - E) * J

    nx = this.curve._mulC(b.redISub(e)).redMul(j); // Y3 = c * E * (C - D)

    ny = this.curve._mulC(e).redMul(c.redISub(d)); // Z3 = E * J

    nz = e.redMul(j);
  }

  return this.curve.point(nx, ny, nz);
};

Point.prototype.dbl = function dbl() {
  if (this.isInfinity()) return this; // Double in extended coordinates

  if (this.curve.extended) return this._extDbl();else return this._projDbl();
};

Point.prototype._extAdd = function _extAdd(p) {
  // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html
  //     #addition-add-2008-hwcd-3
  // 8M
  // A = (Y1 - X1) * (Y2 - X2)
  var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x)); // B = (Y1 + X1) * (Y2 + X2)

  var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x)); // C = T1 * k * T2

  var c = this.t.redMul(this.curve.dd).redMul(p.t); // D = Z1 * 2 * Z2

  var d = this.z.redMul(p.z.redAdd(p.z)); // E = B - A

  var e = b.redSub(a); // F = D - C

  var f = d.redSub(c); // G = D + C

  var g = d.redAdd(c); // H = B + A

  var h = b.redAdd(a); // X3 = E * F

  var nx = e.redMul(f); // Y3 = G * H

  var ny = g.redMul(h); // T3 = E * H

  var nt = e.redMul(h); // Z3 = F * G

  var nz = f.redMul(g);
  return this.curve.point(nx, ny, nz, nt);
};

Point.prototype._projAdd = function _projAdd(p) {
  // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html
  //     #addition-add-2008-bbjlp
  //     #addition-add-2007-bl
  // 10M + 1S
  // A = Z1 * Z2
  var a = this.z.redMul(p.z); // B = A^2

  var b = a.redSqr(); // C = X1 * X2

  var c = this.x.redMul(p.x); // D = Y1 * Y2

  var d = this.y.redMul(p.y); // E = d * C * D

  var e = this.curve.d.redMul(c).redMul(d); // F = B - E

  var f = b.redSub(e); // G = B + E

  var g = b.redAdd(e); // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)

  var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
  var nx = a.redMul(f).redMul(tmp);
  var ny;
  var nz;

  if (this.curve.twisted) {
    // Y3 = A * G * (D - a * C)
    ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c))); // Z3 = F * G

    nz = f.redMul(g);
  } else {
    // Y3 = A * G * (D - C)
    ny = a.redMul(g).redMul(d.redSub(c)); // Z3 = c * F * G

    nz = this.curve._mulC(f).redMul(g);
  }

  return this.curve.point(nx, ny, nz);
};

Point.prototype.add = function add(p) {
  if (this.isInfinity()) return p;
  if (p.isInfinity()) return this;
  if (this.curve.extended) return this._extAdd(p);else return this._projAdd(p);
};

Point.prototype.mul = function mul(k) {
  if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else return this.curve._wnafMul(this, k);
};

Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
};

Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
  return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
};

Point.prototype.normalize = function normalize() {
  if (this.zOne) return this; // Normalize coordinates

  var zi = this.z.redInvm();
  this.x = this.x.redMul(zi);
  this.y = this.y.redMul(zi);
  if (this.t) this.t = this.t.redMul(zi);
  this.z = this.curve.one;
  this.zOne = true;
  return this;
};

Point.prototype.neg = function neg() {
  return this.curve.point(this.x.redNeg(), this.y, this.z, this.t && this.t.redNeg());
};

Point.prototype.getX = function getX() {
  this.normalize();
  return this.x.fromRed();
};

Point.prototype.getY = function getY() {
  this.normalize();
  return this.y.fromRed();
};

Point.prototype.eq = function eq(other) {
  return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
};

Point.prototype.eqXToP = function eqXToP(x) {
  var rx = x.toRed(this.curve.red).redMul(this.z);
  if (this.x.cmp(rx) === 0) return true;
  var xc = x.clone();
  var t = this.curve.redN.redMul(this.z);

  for (;;) {
    xc.iadd(this.curve.n);
    if (xc.cmp(this.curve.p) >= 0) return false;
    rx.redIAdd(t);
    if (this.x.cmp(rx) === 0) return true;
  }
}; // Compatibility with BaseCurve


Point.prototype.toP = Point.prototype.normalize;
Point.prototype.mixedAdd = Point.prototype.add;

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curve/index.js":
/*!***********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curve/index.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var curve = exports;
curve.base = __webpack_require__(/*! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js");
curve.short = __webpack_require__(/*! ./short */ "./node_modules/elliptic/lib/elliptic/curve/short.js");
curve.mont = __webpack_require__(/*! ./mont */ "./node_modules/elliptic/lib/elliptic/curve/mont.js");
curve.edwards = __webpack_require__(/*! ./edwards */ "./node_modules/elliptic/lib/elliptic/curve/edwards.js");

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curve/mont.js":
/*!**********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curve/mont.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Base = __webpack_require__(/*! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

function MontCurve(conf) {
  Base.call(this, 'mont', conf);
  this.a = new BN(conf.a, 16).toRed(this.red);
  this.b = new BN(conf.b, 16).toRed(this.red);
  this.i4 = new BN(4).toRed(this.red).redInvm();
  this.two = new BN(2).toRed(this.red);
  this.a24 = this.i4.redMul(this.a.redAdd(this.two));
}

inherits(MontCurve, Base);
module.exports = MontCurve;

MontCurve.prototype.validate = function validate(point) {
  var x = point.normalize().x;
  var x2 = x.redSqr();
  var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
  var y = rhs.redSqrt();
  return y.redSqr().cmp(rhs) === 0;
};

function Point(curve, x, z) {
  Base.BasePoint.call(this, curve, 'projective');

  if (x === null && z === null) {
    this.x = this.curve.one;
    this.z = this.curve.zero;
  } else {
    this.x = new BN(x, 16);
    this.z = new BN(z, 16);
    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.z.red) this.z = this.z.toRed(this.curve.red);
  }
}

inherits(Point, Base.BasePoint);

MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
  return this.point(utils.toArray(bytes, enc), 1);
};

MontCurve.prototype.point = function point(x, z) {
  return new Point(this, x, z);
};

MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
  return Point.fromJSON(this, obj);
};

Point.prototype.precompute = function precompute() {// No-op
};

Point.prototype._encode = function _encode() {
  return this.getX().toArray('be', this.curve.p.byteLength());
};

Point.fromJSON = function fromJSON(curve, obj) {
  return new Point(curve, obj[0], obj[1] || curve.one);
};

Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' z: ' + this.z.fromRed().toString(16, 2) + '>';
};

Point.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.z.cmpn(0) === 0;
};

Point.prototype.dbl = function dbl() {
  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3
  // 2M + 2S + 4A
  // A = X1 + Z1
  var a = this.x.redAdd(this.z); // AA = A^2

  var aa = a.redSqr(); // B = X1 - Z1

  var b = this.x.redSub(this.z); // BB = B^2

  var bb = b.redSqr(); // C = AA - BB

  var c = aa.redSub(bb); // X3 = AA * BB

  var nx = aa.redMul(bb); // Z3 = C * (BB + A24 * C)

  var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
  return this.curve.point(nx, nz);
};

Point.prototype.add = function add() {
  throw new Error('Not supported on Montgomery curve');
};

Point.prototype.diffAdd = function diffAdd(p, diff) {
  // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3
  // 4M + 2S + 6A
  // A = X2 + Z2
  var a = this.x.redAdd(this.z); // B = X2 - Z2

  var b = this.x.redSub(this.z); // C = X3 + Z3

  var c = p.x.redAdd(p.z); // D = X3 - Z3

  var d = p.x.redSub(p.z); // DA = D * A

  var da = d.redMul(a); // CB = C * B

  var cb = c.redMul(b); // X5 = Z1 * (DA + CB)^2

  var nx = diff.z.redMul(da.redAdd(cb).redSqr()); // Z5 = X1 * (DA - CB)^2

  var nz = diff.x.redMul(da.redISub(cb).redSqr());
  return this.curve.point(nx, nz);
};

Point.prototype.mul = function mul(k) {
  var t = k.clone();
  var a = this; // (N / 2) * Q + Q

  var b = this.curve.point(null, null); // (N / 2) * Q

  var c = this; // Q

  for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1)) {
    bits.push(t.andln(1));
  }

  for (var i = bits.length - 1; i >= 0; i--) {
    if (bits[i] === 0) {
      // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q
      a = a.diffAdd(b, c); // N * Q = 2 * ((N / 2) * Q + Q))

      b = b.dbl();
    } else {
      // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)
      b = a.diffAdd(b, c); // N * Q + Q = 2 * ((N / 2) * Q + Q)

      a = a.dbl();
    }
  }

  return b;
};

Point.prototype.mulAdd = function mulAdd() {
  throw new Error('Not supported on Montgomery curve');
};

Point.prototype.jumlAdd = function jumlAdd() {
  throw new Error('Not supported on Montgomery curve');
};

Point.prototype.eq = function eq(other) {
  return this.getX().cmp(other.getX()) === 0;
};

Point.prototype.normalize = function normalize() {
  this.x = this.x.redMul(this.z.redInvm());
  this.z = this.curve.one;
  return this;
};

Point.prototype.getX = function getX() {
  // Normalize coordinates
  this.normalize();
  return this.x.fromRed();
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curve/short.js":
/*!***********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curve/short.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Base = __webpack_require__(/*! ./base */ "./node_modules/elliptic/lib/elliptic/curve/base.js");

var assert = utils.assert;

function ShortCurve(conf) {
  Base.call(this, 'short', conf);
  this.a = new BN(conf.a, 16).toRed(this.red);
  this.b = new BN(conf.b, 16).toRed(this.red);
  this.tinv = this.two.redInvm();
  this.zeroA = this.a.fromRed().cmpn(0) === 0;
  this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0; // If the curve is endomorphic, precalculate beta and lambda

  this.endo = this._getEndomorphism(conf);
  this._endoWnafT1 = new Array(4);
  this._endoWnafT2 = new Array(4);
}

inherits(ShortCurve, Base);
module.exports = ShortCurve;

ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
  // No efficient endomorphism
  if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1) return; // Compute beta and lambda, that lambda * P = (beta * Px; Py)

  var beta;
  var lambda;

  if (conf.beta) {
    beta = new BN(conf.beta, 16).toRed(this.red);
  } else {
    var betas = this._getEndoRoots(this.p); // Choose the smallest beta


    beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
    beta = beta.toRed(this.red);
  }

  if (conf.lambda) {
    lambda = new BN(conf.lambda, 16);
  } else {
    // Choose the lambda that is matching selected beta
    var lambdas = this._getEndoRoots(this.n);

    if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
      lambda = lambdas[0];
    } else {
      lambda = lambdas[1];
      assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
    }
  } // Get basis vectors, used for balanced length-two representation


  var basis;

  if (conf.basis) {
    basis = conf.basis.map(function (vec) {
      return {
        a: new BN(vec.a, 16),
        b: new BN(vec.b, 16)
      };
    });
  } else {
    basis = this._getEndoBasis(lambda);
  }

  return {
    beta: beta,
    lambda: lambda,
    basis: basis
  };
};

ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
  // Find roots of for x^2 + x + 1 in F
  // Root = (-1 +- Sqrt(-3)) / 2
  //
  var red = num === this.p ? this.red : BN.mont(num);
  var tinv = new BN(2).toRed(red).redInvm();
  var ntinv = tinv.redNeg();
  var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
  var l1 = ntinv.redAdd(s).fromRed();
  var l2 = ntinv.redSub(s).fromRed();
  return [l1, l2];
};

ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
  // aprxSqrt >= sqrt(this.n)
  var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2)); // 3.74
  // Run EGCD, until r(L + 1) < aprxSqrt

  var u = lambda;
  var v = this.n.clone();
  var x1 = new BN(1);
  var y1 = new BN(0);
  var x2 = new BN(0);
  var y2 = new BN(1); // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)

  var a0;
  var b0; // First vector

  var a1;
  var b1; // Second vector

  var a2;
  var b2;
  var prevR;
  var i = 0;
  var r;
  var x;

  while (u.cmpn(0) !== 0) {
    var q = v.div(u);
    r = v.sub(q.mul(u));
    x = x2.sub(q.mul(x1));
    var y = y2.sub(q.mul(y1));

    if (!a1 && r.cmp(aprxSqrt) < 0) {
      a0 = prevR.neg();
      b0 = x1;
      a1 = r.neg();
      b1 = x;
    } else if (a1 && ++i === 2) {
      break;
    }

    prevR = r;
    v = u;
    u = r;
    x2 = x1;
    x1 = x;
    y2 = y1;
    y1 = y;
  }

  a2 = r.neg();
  b2 = x;
  var len1 = a1.sqr().add(b1.sqr());
  var len2 = a2.sqr().add(b2.sqr());

  if (len2.cmp(len1) >= 0) {
    a2 = a0;
    b2 = b0;
  } // Normalize signs


  if (a1.negative) {
    a1 = a1.neg();
    b1 = b1.neg();
  }

  if (a2.negative) {
    a2 = a2.neg();
    b2 = b2.neg();
  }

  return [{
    a: a1,
    b: b1
  }, {
    a: a2,
    b: b2
  }];
};

ShortCurve.prototype._endoSplit = function _endoSplit(k) {
  var basis = this.endo.basis;
  var v1 = basis[0];
  var v2 = basis[1];
  var c1 = v2.b.mul(k).divRound(this.n);
  var c2 = v1.b.neg().mul(k).divRound(this.n);
  var p1 = c1.mul(v1.a);
  var p2 = c2.mul(v2.a);
  var q1 = c1.mul(v1.b);
  var q2 = c2.mul(v2.b); // Calculate answer

  var k1 = k.sub(p1).sub(p2);
  var k2 = q1.add(q2).neg();
  return {
    k1: k1,
    k2: k2
  };
};

ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
  x = new BN(x, 16);
  if (!x.red) x = x.toRed(this.red);
  var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
  var y = y2.redSqrt();
  if (y.redSqr().redSub(y2).cmp(this.zero) !== 0) throw new Error('invalid point'); // XXX Is there any way to tell if the number is odd without converting it
  // to non-red form?

  var isOdd = y.fromRed().isOdd();
  if (odd && !isOdd || !odd && isOdd) y = y.redNeg();
  return this.point(x, y);
};

ShortCurve.prototype.validate = function validate(point) {
  if (point.inf) return true;
  var x = point.x;
  var y = point.y;
  var ax = this.a.redMul(x);
  var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
  return y.redSqr().redISub(rhs).cmpn(0) === 0;
};

ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
  var npoints = this._endoWnafT1;
  var ncoeffs = this._endoWnafT2;

  for (var i = 0; i < points.length; i++) {
    var split = this._endoSplit(coeffs[i]);

    var p = points[i];

    var beta = p._getBeta();

    if (split.k1.negative) {
      split.k1.ineg();
      p = p.neg(true);
    }

    if (split.k2.negative) {
      split.k2.ineg();
      beta = beta.neg(true);
    }

    npoints[i * 2] = p;
    npoints[i * 2 + 1] = beta;
    ncoeffs[i * 2] = split.k1;
    ncoeffs[i * 2 + 1] = split.k2;
  }

  var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult); // Clean-up references to points and coefficients


  for (var j = 0; j < i * 2; j++) {
    npoints[j] = null;
    ncoeffs[j] = null;
  }

  return res;
};

function Point(curve, x, y, isRed) {
  Base.BasePoint.call(this, curve, 'affine');

  if (x === null && y === null) {
    this.x = null;
    this.y = null;
    this.inf = true;
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16); // Force redgomery representation when loading from JSON

    if (isRed) {
      this.x.forceRed(this.curve.red);
      this.y.forceRed(this.curve.red);
    }

    if (!this.x.red) this.x = this.x.toRed(this.curve.red);
    if (!this.y.red) this.y = this.y.toRed(this.curve.red);
    this.inf = false;
  }
}

inherits(Point, Base.BasePoint);

ShortCurve.prototype.point = function point(x, y, isRed) {
  return new Point(this, x, y, isRed);
};

ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
  return Point.fromJSON(this, obj, red);
};

Point.prototype._getBeta = function _getBeta() {
  if (!this.curve.endo) return;
  var pre = this.precomputed;
  if (pre && pre.beta) return pre.beta;
  var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);

  if (pre) {
    var curve = this.curve;

    var endoMul = function endoMul(p) {
      return curve.point(p.x.redMul(curve.endo.beta), p.y);
    };

    pre.beta = beta;
    beta.precomputed = {
      beta: null,
      naf: pre.naf && {
        wnd: pre.naf.wnd,
        points: pre.naf.points.map(endoMul)
      },
      doubles: pre.doubles && {
        step: pre.doubles.step,
        points: pre.doubles.points.map(endoMul)
      }
    };
  }

  return beta;
};

Point.prototype.toJSON = function toJSON() {
  if (!this.precomputed) return [this.x, this.y];
  return [this.x, this.y, this.precomputed && {
    doubles: this.precomputed.doubles && {
      step: this.precomputed.doubles.step,
      points: this.precomputed.doubles.points.slice(1)
    },
    naf: this.precomputed.naf && {
      wnd: this.precomputed.naf.wnd,
      points: this.precomputed.naf.points.slice(1)
    }
  }];
};

Point.fromJSON = function fromJSON(curve, obj, red) {
  if (typeof obj === 'string') obj = JSON.parse(obj);
  var res = curve.point(obj[0], obj[1], red);
  if (!obj[2]) return res;

  function obj2point(obj) {
    return curve.point(obj[0], obj[1], red);
  }

  var pre = obj[2];
  res.precomputed = {
    beta: null,
    doubles: pre.doubles && {
      step: pre.doubles.step,
      points: [res].concat(pre.doubles.points.map(obj2point))
    },
    naf: pre.naf && {
      wnd: pre.naf.wnd,
      points: [res].concat(pre.naf.points.map(obj2point))
    }
  };
  return res;
};

Point.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC Point Infinity>';
  return '<EC Point x: ' + this.x.fromRed().toString(16, 2) + ' y: ' + this.y.fromRed().toString(16, 2) + '>';
};

Point.prototype.isInfinity = function isInfinity() {
  return this.inf;
};

Point.prototype.add = function add(p) {
  // O + P = P
  if (this.inf) return p; // P + O = P

  if (p.inf) return this; // P + P = 2P

  if (this.eq(p)) return this.dbl(); // P + (-P) = O

  if (this.neg().eq(p)) return this.curve.point(null, null); // P + Q = O

  if (this.x.cmp(p.x) === 0) return this.curve.point(null, null);
  var c = this.y.redSub(p.y);
  if (c.cmpn(0) !== 0) c = c.redMul(this.x.redSub(p.x).redInvm());
  var nx = c.redSqr().redISub(this.x).redISub(p.x);
  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
  return this.curve.point(nx, ny);
};

Point.prototype.dbl = function dbl() {
  if (this.inf) return this; // 2P = O

  var ys1 = this.y.redAdd(this.y);
  if (ys1.cmpn(0) === 0) return this.curve.point(null, null);
  var a = this.curve.a;
  var x2 = this.x.redSqr();
  var dyinv = ys1.redInvm();
  var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
  var nx = c.redSqr().redISub(this.x.redAdd(this.x));
  var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
  return this.curve.point(nx, ny);
};

Point.prototype.getX = function getX() {
  return this.x.fromRed();
};

Point.prototype.getY = function getY() {
  return this.y.fromRed();
};

Point.prototype.mul = function mul(k) {
  k = new BN(k, 16);
  if (this.isInfinity()) return this;else if (this._hasDoubles(k)) return this.curve._fixedNafMul(this, k);else if (this.curve.endo) return this.curve._endoWnafMulAdd([this], [k]);else return this.curve._wnafMul(this, k);
};

Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
  var points = [this, p2];
  var coeffs = [k1, k2];
  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs);else return this.curve._wnafMulAdd(1, points, coeffs, 2);
};

Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
  var points = [this, p2];
  var coeffs = [k1, k2];
  if (this.curve.endo) return this.curve._endoWnafMulAdd(points, coeffs, true);else return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
};

Point.prototype.eq = function eq(p) {
  return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
};

Point.prototype.neg = function neg(_precompute) {
  if (this.inf) return this;
  var res = this.curve.point(this.x, this.y.redNeg());

  if (_precompute && this.precomputed) {
    var pre = this.precomputed;

    var negate = function negate(p) {
      return p.neg();
    };

    res.precomputed = {
      naf: pre.naf && {
        wnd: pre.naf.wnd,
        points: pre.naf.points.map(negate)
      },
      doubles: pre.doubles && {
        step: pre.doubles.step,
        points: pre.doubles.points.map(negate)
      }
    };
  }

  return res;
};

Point.prototype.toJ = function toJ() {
  if (this.inf) return this.curve.jpoint(null, null, null);
  var res = this.curve.jpoint(this.x, this.y, this.curve.one);
  return res;
};

function JPoint(curve, x, y, z) {
  Base.BasePoint.call(this, curve, 'jacobian');

  if (x === null && y === null && z === null) {
    this.x = this.curve.one;
    this.y = this.curve.one;
    this.z = new BN(0);
  } else {
    this.x = new BN(x, 16);
    this.y = new BN(y, 16);
    this.z = new BN(z, 16);
  }

  if (!this.x.red) this.x = this.x.toRed(this.curve.red);
  if (!this.y.red) this.y = this.y.toRed(this.curve.red);
  if (!this.z.red) this.z = this.z.toRed(this.curve.red);
  this.zOne = this.z === this.curve.one;
}

inherits(JPoint, Base.BasePoint);

ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
  return new JPoint(this, x, y, z);
};

JPoint.prototype.toP = function toP() {
  if (this.isInfinity()) return this.curve.point(null, null);
  var zinv = this.z.redInvm();
  var zinv2 = zinv.redSqr();
  var ax = this.x.redMul(zinv2);
  var ay = this.y.redMul(zinv2).redMul(zinv);
  return this.curve.point(ax, ay);
};

JPoint.prototype.neg = function neg() {
  return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
};

JPoint.prototype.add = function add(p) {
  // O + P = P
  if (this.isInfinity()) return p; // P + O = P

  if (p.isInfinity()) return this; // 12M + 4S + 7A

  var pz2 = p.z.redSqr();
  var z2 = this.z.redSqr();
  var u1 = this.x.redMul(pz2);
  var u2 = p.x.redMul(z2);
  var s1 = this.y.redMul(pz2.redMul(p.z));
  var s2 = p.y.redMul(z2.redMul(this.z));
  var h = u1.redSub(u2);
  var r = s1.redSub(s2);

  if (h.cmpn(0) === 0) {
    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();
  }

  var h2 = h.redSqr();
  var h3 = h2.redMul(h);
  var v = u1.redMul(h2);
  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
  var nz = this.z.redMul(p.z).redMul(h);
  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype.mixedAdd = function mixedAdd(p) {
  // O + P = P
  if (this.isInfinity()) return p.toJ(); // P + O = P

  if (p.isInfinity()) return this; // 8M + 3S + 7A

  var z2 = this.z.redSqr();
  var u1 = this.x;
  var u2 = p.x.redMul(z2);
  var s1 = this.y;
  var s2 = p.y.redMul(z2).redMul(this.z);
  var h = u1.redSub(u2);
  var r = s1.redSub(s2);

  if (h.cmpn(0) === 0) {
    if (r.cmpn(0) !== 0) return this.curve.jpoint(null, null, null);else return this.dbl();
  }

  var h2 = h.redSqr();
  var h3 = h2.redMul(h);
  var v = u1.redMul(h2);
  var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
  var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
  var nz = this.z.redMul(h);
  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype.dblp = function dblp(pow) {
  if (pow === 0) return this;
  if (this.isInfinity()) return this;
  if (!pow) return this.dbl();

  if (this.curve.zeroA || this.curve.threeA) {
    var r = this;

    for (var i = 0; i < pow; i++) {
      r = r.dbl();
    }

    return r;
  } // 1M + 2S + 1A + N * (4S + 5M + 8A)
  // N = 1 => 6M + 6S + 9A


  var a = this.curve.a;
  var tinv = this.curve.tinv;
  var jx = this.x;
  var jy = this.y;
  var jz = this.z;
  var jz4 = jz.redSqr().redSqr(); // Reuse results

  var jyd = jy.redAdd(jy);

  for (var i = 0; i < pow; i++) {
    var jx2 = jx.redSqr();
    var jyd2 = jyd.redSqr();
    var jyd4 = jyd2.redSqr();
    var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
    var t1 = jx.redMul(jyd2);
    var nx = c.redSqr().redISub(t1.redAdd(t1));
    var t2 = t1.redISub(nx);
    var dny = c.redMul(t2);
    dny = dny.redIAdd(dny).redISub(jyd4);
    var nz = jyd.redMul(jz);
    if (i + 1 < pow) jz4 = jz4.redMul(jyd4);
    jx = nx;
    jz = nz;
    jyd = dny;
  }

  return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
};

JPoint.prototype.dbl = function dbl() {
  if (this.isInfinity()) return this;
  if (this.curve.zeroA) return this._zeroDbl();else if (this.curve.threeA) return this._threeDbl();else return this._dbl();
};

JPoint.prototype._zeroDbl = function _zeroDbl() {
  var nx;
  var ny;
  var nz; // Z = 1

  if (this.zOne) {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
    //     #doubling-mdbl-2007-bl
    // 1M + 5S + 14A
    // XX = X1^2
    var xx = this.x.redSqr(); // YY = Y1^2

    var yy = this.y.redSqr(); // YYYY = YY^2

    var yyyy = yy.redSqr(); // S = 2 * ((X1 + YY)^2 - XX - YYYY)

    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
    s = s.redIAdd(s); // M = 3 * XX + a; a = 0

    var m = xx.redAdd(xx).redIAdd(xx); // T = M ^ 2 - 2*S

    var t = m.redSqr().redISub(s).redISub(s); // 8 * YYYY

    var yyyy8 = yyyy.redIAdd(yyyy);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    yyyy8 = yyyy8.redIAdd(yyyy8); // X3 = T

    nx = t; // Y3 = M * (S - T) - 8 * YYYY

    ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2*Y1

    nz = this.y.redAdd(this.y);
  } else {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html
    //     #doubling-dbl-2009-l
    // 2M + 5S + 13A
    // A = X1^2
    var a = this.x.redSqr(); // B = Y1^2

    var b = this.y.redSqr(); // C = B^2

    var c = b.redSqr(); // D = 2 * ((X1 + B)^2 - A - C)

    var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
    d = d.redIAdd(d); // E = 3 * A

    var e = a.redAdd(a).redIAdd(a); // F = E^2

    var f = e.redSqr(); // 8 * C

    var c8 = c.redIAdd(c);
    c8 = c8.redIAdd(c8);
    c8 = c8.redIAdd(c8); // X3 = F - 2 * D

    nx = f.redISub(d).redISub(d); // Y3 = E * (D - X3) - 8 * C

    ny = e.redMul(d.redISub(nx)).redISub(c8); // Z3 = 2 * Y1 * Z1

    nz = this.y.redMul(this.z);
    nz = nz.redIAdd(nz);
  }

  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype._threeDbl = function _threeDbl() {
  var nx;
  var ny;
  var nz; // Z = 1

  if (this.zOne) {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html
    //     #doubling-mdbl-2007-bl
    // 1M + 5S + 15A
    // XX = X1^2
    var xx = this.x.redSqr(); // YY = Y1^2

    var yy = this.y.redSqr(); // YYYY = YY^2

    var yyyy = yy.redSqr(); // S = 2 * ((X1 + YY)^2 - XX - YYYY)

    var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
    s = s.redIAdd(s); // M = 3 * XX + a

    var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a); // T = M^2 - 2 * S

    var t = m.redSqr().redISub(s).redISub(s); // X3 = T

    nx = t; // Y3 = M * (S - T) - 8 * YYYY

    var yyyy8 = yyyy.redIAdd(yyyy);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    yyyy8 = yyyy8.redIAdd(yyyy8);
    ny = m.redMul(s.redISub(t)).redISub(yyyy8); // Z3 = 2 * Y1

    nz = this.y.redAdd(this.y);
  } else {
    // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b
    // 3M + 5S
    // delta = Z1^2
    var delta = this.z.redSqr(); // gamma = Y1^2

    var gamma = this.y.redSqr(); // beta = X1 * gamma

    var beta = this.x.redMul(gamma); // alpha = 3 * (X1 - delta) * (X1 + delta)

    var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
    alpha = alpha.redAdd(alpha).redIAdd(alpha); // X3 = alpha^2 - 8 * beta

    var beta4 = beta.redIAdd(beta);
    beta4 = beta4.redIAdd(beta4);
    var beta8 = beta4.redAdd(beta4);
    nx = alpha.redSqr().redISub(beta8); // Z3 = (Y1 + Z1)^2 - gamma - delta

    nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta); // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2

    var ggamma8 = gamma.redSqr();
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ggamma8 = ggamma8.redIAdd(ggamma8);
    ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
  }

  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype._dbl = function _dbl() {
  var a = this.curve.a; // 4M + 6S + 10A

  var jx = this.x;
  var jy = this.y;
  var jz = this.z;
  var jz4 = jz.redSqr().redSqr();
  var jx2 = jx.redSqr();
  var jy2 = jy.redSqr();
  var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
  var jxd4 = jx.redAdd(jx);
  jxd4 = jxd4.redIAdd(jxd4);
  var t1 = jxd4.redMul(jy2);
  var nx = c.redSqr().redISub(t1.redAdd(t1));
  var t2 = t1.redISub(nx);
  var jyd8 = jy2.redSqr();
  jyd8 = jyd8.redIAdd(jyd8);
  jyd8 = jyd8.redIAdd(jyd8);
  jyd8 = jyd8.redIAdd(jyd8);
  var ny = c.redMul(t2).redISub(jyd8);
  var nz = jy.redAdd(jy).redMul(jz);
  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype.trpl = function trpl() {
  if (!this.curve.zeroA) return this.dbl().add(this); // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl
  // 5M + 10S + ...
  // XX = X1^2

  var xx = this.x.redSqr(); // YY = Y1^2

  var yy = this.y.redSqr(); // ZZ = Z1^2

  var zz = this.z.redSqr(); // YYYY = YY^2

  var yyyy = yy.redSqr(); // M = 3 * XX + a * ZZ2; a = 0

  var m = xx.redAdd(xx).redIAdd(xx); // MM = M^2

  var mm = m.redSqr(); // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM

  var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
  e = e.redIAdd(e);
  e = e.redAdd(e).redIAdd(e);
  e = e.redISub(mm); // EE = E^2

  var ee = e.redSqr(); // T = 16*YYYY

  var t = yyyy.redIAdd(yyyy);
  t = t.redIAdd(t);
  t = t.redIAdd(t);
  t = t.redIAdd(t); // U = (M + E)^2 - MM - EE - T

  var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t); // X3 = 4 * (X1 * EE - 4 * YY * U)

  var yyu4 = yy.redMul(u);
  yyu4 = yyu4.redIAdd(yyu4);
  yyu4 = yyu4.redIAdd(yyu4);
  var nx = this.x.redMul(ee).redISub(yyu4);
  nx = nx.redIAdd(nx);
  nx = nx.redIAdd(nx); // Y3 = 8 * Y1 * (U * (T - U) - E * EE)

  var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
  ny = ny.redIAdd(ny);
  ny = ny.redIAdd(ny);
  ny = ny.redIAdd(ny); // Z3 = (Z1 + E)^2 - ZZ - EE

  var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
  return this.curve.jpoint(nx, ny, nz);
};

JPoint.prototype.mul = function mul(k, kbase) {
  k = new BN(k, kbase);
  return this.curve._wnafMul(this, k);
};

JPoint.prototype.eq = function eq(p) {
  if (p.type === 'affine') return this.eq(p.toJ());
  if (this === p) return true; // x1 * z2^2 == x2 * z1^2

  var z2 = this.z.redSqr();
  var pz2 = p.z.redSqr();
  if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0) return false; // y1 * z2^3 == y2 * z1^3

  var z3 = z2.redMul(this.z);
  var pz3 = pz2.redMul(p.z);
  return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
};

JPoint.prototype.eqXToP = function eqXToP(x) {
  var zs = this.z.redSqr();
  var rx = x.toRed(this.curve.red).redMul(zs);
  if (this.x.cmp(rx) === 0) return true;
  var xc = x.clone();
  var t = this.curve.redN.redMul(zs);

  for (;;) {
    xc.iadd(this.curve.n);
    if (xc.cmp(this.curve.p) >= 0) return false;
    rx.redIAdd(t);
    if (this.x.cmp(rx) === 0) return true;
  }
};

JPoint.prototype.inspect = function inspect() {
  if (this.isInfinity()) return '<EC JPoint Infinity>';
  return '<EC JPoint x: ' + this.x.toString(16, 2) + ' y: ' + this.y.toString(16, 2) + ' z: ' + this.z.toString(16, 2) + '>';
};

JPoint.prototype.isInfinity = function isInfinity() {
  // XXX This code assumes that zero is always zero in red
  return this.z.cmpn(0) === 0;
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/curves.js":
/*!******************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/curves.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var curves = exports;

var hash = __webpack_require__(/*! hash.js */ "./node_modules/hash.js/lib/hash.js");

var curve = __webpack_require__(/*! ./curve */ "./node_modules/elliptic/lib/elliptic/curve/index.js");

var utils = __webpack_require__(/*! ./utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;

function PresetCurve(options) {
  if (options.type === 'short') this.curve = new curve.short(options);else if (options.type === 'edwards') this.curve = new curve.edwards(options);else this.curve = new curve.mont(options);
  this.g = this.curve.g;
  this.n = this.curve.n;
  this.hash = options.hash;
  assert(this.g.validate(), 'Invalid curve');
  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');
}

curves.PresetCurve = PresetCurve;

function defineCurve(name, options) {
  Object.defineProperty(curves, name, {
    configurable: true,
    enumerable: true,
    get: function get() {
      var curve = new PresetCurve(options);
      Object.defineProperty(curves, name, {
        configurable: true,
        enumerable: true,
        value: curve
      });
      return curve;
    }
  });
}

defineCurve('p192', {
  type: 'short',
  prime: 'p192',
  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',
  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',
  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',
  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',
  hash: hash.sha256,
  gRed: false,
  g: ['188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012', '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811']
});
defineCurve('p224', {
  type: 'short',
  prime: 'p224',
  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',
  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',
  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',
  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',
  hash: hash.sha256,
  gRed: false,
  g: ['b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21', 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34']
});
defineCurve('p256', {
  type: 'short',
  prime: null,
  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',
  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',
  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',
  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',
  hash: hash.sha256,
  gRed: false,
  g: ['6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296', '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5']
});
defineCurve('p384', {
  type: 'short',
  prime: null,
  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 ffffffff',
  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'fffffffe ffffffff 00000000 00000000 fffffffc',
  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' + '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',
  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' + 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',
  hash: hash.sha384,
  gRed: false,
  g: ['aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' + '5502f25d bf55296c 3a545e38 72760ab7', '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' + '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f']
});
defineCurve('p521', {
  type: 'short',
  prime: null,
  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff',
  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff ffffffff ffffffff fffffffc',
  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' + '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' + '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',
  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' + 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' + 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',
  hash: hash.sha512,
  gRed: false,
  g: ['000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' + '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' + 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66', '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' + '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' + '3fad0761 353c7086 a272c240 88be9476 9fd16650']
});
defineCurve('curve25519', {
  type: 'mont',
  prime: 'p25519',
  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
  a: '76d06',
  b: '1',
  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
  hash: hash.sha256,
  gRed: false,
  g: ['9']
});
defineCurve('ed25519', {
  type: 'edwards',
  prime: 'p25519',
  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',
  a: '-1',
  c: '1',
  // -121665 * (121666^(-1)) (mod P)
  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',
  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',
  hash: hash.sha256,
  gRed: false,
  g: ['216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a', // 4/5
  '6666666666666666666666666666666666666666666666666666666666666658']
});
var pre;

try {
  pre = __webpack_require__(/*! ./precomputed/secp256k1 */ "./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js");
} catch (e) {
  pre = undefined;
}

defineCurve('secp256k1', {
  type: 'short',
  prime: 'k256',
  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',
  a: '0',
  b: '7',
  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',
  h: '1',
  hash: hash.sha256,
  // Precomputed endomorphism
  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',
  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',
  basis: [{
    a: '3086d221a7d46bcde86c90e49284eb15',
    b: '-e4437ed6010e88286f547fa90abfe4c3'
  }, {
    a: '114ca50f7a8e2f3f657c1108d9d44cfd8',
    b: '3086d221a7d46bcde86c90e49284eb15'
  }],
  gRed: false,
  g: ['79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8', pre]
});

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/ec/index.js":
/*!********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/ec/index.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var HmacDRBG = __webpack_require__(/*! hmac-drbg */ "./node_modules/hmac-drbg/lib/hmac-drbg.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var curves = __webpack_require__(/*! ../curves */ "./node_modules/elliptic/lib/elliptic/curves.js");

var rand = __webpack_require__(/*! brorand */ "./node_modules/brorand/index.js");

var assert = utils.assert;

var KeyPair = __webpack_require__(/*! ./key */ "./node_modules/elliptic/lib/elliptic/ec/key.js");

var Signature = __webpack_require__(/*! ./signature */ "./node_modules/elliptic/lib/elliptic/ec/signature.js");

function EC(options) {
  if (!(this instanceof EC)) return new EC(options); // Shortcut `elliptic.ec(curve-name)`

  if (typeof options === 'string') {
    assert(curves.hasOwnProperty(options), 'Unknown curve ' + options);
    options = curves[options];
  } // Shortcut for `elliptic.ec(elliptic.curves.curveName)`


  if (options instanceof curves.PresetCurve) options = {
    curve: options
  };
  this.curve = options.curve.curve;
  this.n = this.curve.n;
  this.nh = this.n.ushrn(1);
  this.g = this.curve.g; // Point on curve

  this.g = options.curve.g;
  this.g.precompute(options.curve.n.bitLength() + 1); // Hash for function for DRBG

  this.hash = options.hash || options.curve.hash;
}

module.exports = EC;

EC.prototype.keyPair = function keyPair(options) {
  return new KeyPair(this, options);
};

EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
  return KeyPair.fromPrivate(this, priv, enc);
};

EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
  return KeyPair.fromPublic(this, pub, enc);
};

EC.prototype.genKeyPair = function genKeyPair(options) {
  if (!options) options = {}; // Instantiate Hmac_DRBG

  var drbg = new HmacDRBG({
    hash: this.hash,
    pers: options.pers,
    persEnc: options.persEnc || 'utf8',
    entropy: options.entropy || rand(this.hash.hmacStrength),
    entropyEnc: options.entropy && options.entropyEnc || 'utf8',
    nonce: this.n.toArray()
  });
  var bytes = this.n.byteLength();
  var ns2 = this.n.sub(new BN(2));

  do {
    var priv = new BN(drbg.generate(bytes));
    if (priv.cmp(ns2) > 0) continue;
    priv.iaddn(1);
    return this.keyFromPrivate(priv);
  } while (true);
};

EC.prototype._truncateToN = function truncateToN(msg, truncOnly) {
  var delta = msg.byteLength() * 8 - this.n.bitLength();
  if (delta > 0) msg = msg.ushrn(delta);
  if (!truncOnly && msg.cmp(this.n) >= 0) return msg.sub(this.n);else return msg;
};

EC.prototype.sign = function sign(msg, key, enc, options) {
  if (_typeof(enc) === 'object') {
    options = enc;
    enc = null;
  }

  if (!options) options = {};
  key = this.keyFromPrivate(key, enc);
  msg = this._truncateToN(new BN(msg, 16)); // Zero-extend key to provide enough entropy

  var bytes = this.n.byteLength();
  var bkey = key.getPrivate().toArray('be', bytes); // Zero-extend nonce to have the same byte size as N

  var nonce = msg.toArray('be', bytes); // Instantiate Hmac_DRBG

  var drbg = new HmacDRBG({
    hash: this.hash,
    entropy: bkey,
    nonce: nonce,
    pers: options.pers,
    persEnc: options.persEnc || 'utf8'
  }); // Number of bytes to generate

  var ns1 = this.n.sub(new BN(1));

  for (var iter = 0; true; iter++) {
    var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
    k = this._truncateToN(k, true);
    if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0) continue;
    var kp = this.g.mul(k);
    if (kp.isInfinity()) continue;
    var kpX = kp.getX();
    var r = kpX.umod(this.n);
    if (r.cmpn(0) === 0) continue;
    var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));
    s = s.umod(this.n);
    if (s.cmpn(0) === 0) continue;
    var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0); // Use complement of `s`, if it is > `n / 2`

    if (options.canonical && s.cmp(this.nh) > 0) {
      s = this.n.sub(s);
      recoveryParam ^= 1;
    }

    return new Signature({
      r: r,
      s: s,
      recoveryParam: recoveryParam
    });
  }
};

EC.prototype.verify = function verify(msg, signature, key, enc) {
  msg = this._truncateToN(new BN(msg, 16));
  key = this.keyFromPublic(key, enc);
  signature = new Signature(signature, 'hex'); // Perform primitive values validation

  var r = signature.r;
  var s = signature.s;
  if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0) return false;
  if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0) return false; // Validate signature

  var sinv = s.invm(this.n);
  var u1 = sinv.mul(msg).umod(this.n);
  var u2 = sinv.mul(r).umod(this.n);

  if (!this.curve._maxwellTrick) {
    var p = this.g.mulAdd(u1, key.getPublic(), u2);
    if (p.isInfinity()) return false;
    return p.getX().umod(this.n).cmp(r) === 0;
  } // NOTE: Greg Maxwell's trick, inspired by:
  // https://git.io/vad3K


  var p = this.g.jmulAdd(u1, key.getPublic(), u2);
  if (p.isInfinity()) return false; // Compare `p.x` of Jacobian point with `r`,
  // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the
  // inverse of `p.z^2`

  return p.eqXToP(r);
};

EC.prototype.recoverPubKey = function (msg, signature, j, enc) {
  assert((3 & j) === j, 'The recovery param is more than two bits');
  signature = new Signature(signature, enc);
  var n = this.n;
  var e = new BN(msg);
  var r = signature.r;
  var s = signature.s; // A set LSB signifies that the y-coordinate is odd

  var isYOdd = j & 1;
  var isSecondKey = j >> 1;
  if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey) throw new Error('Unable to find sencond key candinate'); // 1.1. Let x = r + jn.

  if (isSecondKey) r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);else r = this.curve.pointFromX(r, isYOdd);
  var rInv = signature.r.invm(n);
  var s1 = n.sub(e).mul(rInv).umod(n);
  var s2 = s.mul(rInv).umod(n); // 1.6.1 Compute Q = r^-1 (sR -  eG)
  //               Q = r^-1 (sR + -eG)

  return this.g.mulAdd(s1, r, s2);
};

EC.prototype.getKeyRecoveryParam = function (e, signature, Q, enc) {
  signature = new Signature(signature, enc);
  if (signature.recoveryParam !== null) return signature.recoveryParam;

  for (var i = 0; i < 4; i++) {
    var Qprime;

    try {
      Qprime = this.recoverPubKey(e, signature, i);
    } catch (e) {
      continue;
    }

    if (Qprime.eq(Q)) return i;
  }

  throw new Error('Unable to find valid recovery factor');
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/ec/key.js":
/*!******************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/ec/key.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;

function KeyPair(ec, options) {
  this.ec = ec;
  this.priv = null;
  this.pub = null; // KeyPair(ec, { priv: ..., pub: ... })

  if (options.priv) this._importPrivate(options.priv, options.privEnc);
  if (options.pub) this._importPublic(options.pub, options.pubEnc);
}

module.exports = KeyPair;

KeyPair.fromPublic = function fromPublic(ec, pub, enc) {
  if (pub instanceof KeyPair) return pub;
  return new KeyPair(ec, {
    pub: pub,
    pubEnc: enc
  });
};

KeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {
  if (priv instanceof KeyPair) return priv;
  return new KeyPair(ec, {
    priv: priv,
    privEnc: enc
  });
};

KeyPair.prototype.validate = function validate() {
  var pub = this.getPublic();
  if (pub.isInfinity()) return {
    result: false,
    reason: 'Invalid public key'
  };
  if (!pub.validate()) return {
    result: false,
    reason: 'Public key is not a point'
  };
  if (!pub.mul(this.ec.curve.n).isInfinity()) return {
    result: false,
    reason: 'Public key * N != O'
  };
  return {
    result: true,
    reason: null
  };
};

KeyPair.prototype.getPublic = function getPublic(compact, enc) {
  // compact is optional argument
  if (typeof compact === 'string') {
    enc = compact;
    compact = null;
  }

  if (!this.pub) this.pub = this.ec.g.mul(this.priv);
  if (!enc) return this.pub;
  return this.pub.encode(enc, compact);
};

KeyPair.prototype.getPrivate = function getPrivate(enc) {
  if (enc === 'hex') return this.priv.toString(16, 2);else return this.priv;
};

KeyPair.prototype._importPrivate = function _importPrivate(key, enc) {
  this.priv = new BN(key, enc || 16); // Ensure that the priv won't be bigger than n, otherwise we may fail
  // in fixed multiplication method

  this.priv = this.priv.umod(this.ec.curve.n);
};

KeyPair.prototype._importPublic = function _importPublic(key, enc) {
  if (key.x || key.y) {
    // Montgomery points only have an `x` coordinate.
    // Weierstrass/Edwards points on the other hand have both `x` and
    // `y` coordinates.
    if (this.ec.curve.type === 'mont') {
      assert(key.x, 'Need x coordinate');
    } else if (this.ec.curve.type === 'short' || this.ec.curve.type === 'edwards') {
      assert(key.x && key.y, 'Need both x and y coordinate');
    }

    this.pub = this.ec.curve.point(key.x, key.y);
    return;
  }

  this.pub = this.ec.curve.decodePoint(key, enc);
}; // ECDH


KeyPair.prototype.derive = function derive(pub) {
  return pub.mul(this.priv).getX();
}; // ECDSA


KeyPair.prototype.sign = function sign(msg, enc, options) {
  return this.ec.sign(msg, this, enc, options);
};

KeyPair.prototype.verify = function verify(msg, signature) {
  return this.ec.verify(msg, signature, this);
};

KeyPair.prototype.inspect = function inspect() {
  return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) + ' pub: ' + (this.pub && this.pub.inspect()) + ' >';
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/ec/signature.js":
/*!************************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/ec/signature.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;

function Signature(options, enc) {
  if (options instanceof Signature) return options;
  if (this._importDER(options, enc)) return;
  assert(options.r && options.s, 'Signature without r or s');
  this.r = new BN(options.r, 16);
  this.s = new BN(options.s, 16);
  if (options.recoveryParam === undefined) this.recoveryParam = null;else this.recoveryParam = options.recoveryParam;
}

module.exports = Signature;

function Position() {
  this.place = 0;
}

function getLength(buf, p) {
  var initial = buf[p.place++];

  if (!(initial & 0x80)) {
    return initial;
  }

  var octetLen = initial & 0xf;
  var val = 0;

  for (var i = 0, off = p.place; i < octetLen; i++, off++) {
    val <<= 8;
    val |= buf[off];
  }

  p.place = off;
  return val;
}

function rmPadding(buf) {
  var i = 0;
  var len = buf.length - 1;

  while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {
    i++;
  }

  if (i === 0) {
    return buf;
  }

  return buf.slice(i);
}

Signature.prototype._importDER = function _importDER(data, enc) {
  data = utils.toArray(data, enc);
  var p = new Position();

  if (data[p.place++] !== 0x30) {
    return false;
  }

  var len = getLength(data, p);

  if (len + p.place !== data.length) {
    return false;
  }

  if (data[p.place++] !== 0x02) {
    return false;
  }

  var rlen = getLength(data, p);
  var r = data.slice(p.place, rlen + p.place);
  p.place += rlen;

  if (data[p.place++] !== 0x02) {
    return false;
  }

  var slen = getLength(data, p);

  if (data.length !== slen + p.place) {
    return false;
  }

  var s = data.slice(p.place, slen + p.place);

  if (r[0] === 0 && r[1] & 0x80) {
    r = r.slice(1);
  }

  if (s[0] === 0 && s[1] & 0x80) {
    s = s.slice(1);
  }

  this.r = new BN(r);
  this.s = new BN(s);
  this.recoveryParam = null;
  return true;
};

function constructLength(arr, len) {
  if (len < 0x80) {
    arr.push(len);
    return;
  }

  var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);
  arr.push(octets | 0x80);

  while (--octets) {
    arr.push(len >>> (octets << 3) & 0xff);
  }

  arr.push(len);
}

Signature.prototype.toDER = function toDER(enc) {
  var r = this.r.toArray();
  var s = this.s.toArray(); // Pad values

  if (r[0] & 0x80) r = [0].concat(r); // Pad values

  if (s[0] & 0x80) s = [0].concat(s);
  r = rmPadding(r);
  s = rmPadding(s);

  while (!s[0] && !(s[1] & 0x80)) {
    s = s.slice(1);
  }

  var arr = [0x02];
  constructLength(arr, r.length);
  arr = arr.concat(r);
  arr.push(0x02);
  constructLength(arr, s.length);
  var backHalf = arr.concat(s);
  var res = [0x30];
  constructLength(res, backHalf.length);
  res = res.concat(backHalf);
  return utils.encode(res, enc);
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/eddsa/index.js":
/*!***********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/eddsa/index.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var hash = __webpack_require__(/*! hash.js */ "./node_modules/hash.js/lib/hash.js");

var curves = __webpack_require__(/*! ../curves */ "./node_modules/elliptic/lib/elliptic/curves.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;
var parseBytes = utils.parseBytes;

var KeyPair = __webpack_require__(/*! ./key */ "./node_modules/elliptic/lib/elliptic/eddsa/key.js");

var Signature = __webpack_require__(/*! ./signature */ "./node_modules/elliptic/lib/elliptic/eddsa/signature.js");

function EDDSA(curve) {
  assert(curve === 'ed25519', 'only tested with ed25519 so far');
  if (!(this instanceof EDDSA)) return new EDDSA(curve);
  var curve = curves[curve].curve;
  this.curve = curve;
  this.g = curve.g;
  this.g.precompute(curve.n.bitLength() + 1);
  this.pointClass = curve.point().constructor;
  this.encodingLength = Math.ceil(curve.n.bitLength() / 8);
  this.hash = hash.sha512;
}

module.exports = EDDSA;
/**
* @param {Array|String} message - message bytes
* @param {Array|String|KeyPair} secret - secret bytes or a keypair
* @returns {Signature} - signature
*/

EDDSA.prototype.sign = function sign(message, secret) {
  message = parseBytes(message);
  var key = this.keyFromSecret(secret);
  var r = this.hashInt(key.messagePrefix(), message);
  var R = this.g.mul(r);
  var Rencoded = this.encodePoint(R);
  var s_ = this.hashInt(Rencoded, key.pubBytes(), message).mul(key.priv());
  var S = r.add(s_).umod(this.curve.n);
  return this.makeSignature({
    R: R,
    S: S,
    Rencoded: Rencoded
  });
};
/**
* @param {Array} message - message bytes
* @param {Array|String|Signature} sig - sig bytes
* @param {Array|String|Point|KeyPair} pub - public key
* @returns {Boolean} - true if public key matches sig of message
*/


EDDSA.prototype.verify = function verify(message, sig, pub) {
  message = parseBytes(message);
  sig = this.makeSignature(sig);
  var key = this.keyFromPublic(pub);
  var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);
  var SG = this.g.mul(sig.S());
  var RplusAh = sig.R().add(key.pub().mul(h));
  return RplusAh.eq(SG);
};

EDDSA.prototype.hashInt = function hashInt() {
  var hash = this.hash();

  for (var i = 0; i < arguments.length; i++) {
    hash.update(arguments[i]);
  }

  return utils.intFromLE(hash.digest()).umod(this.curve.n);
};

EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
  return KeyPair.fromPublic(this, pub);
};

EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
  return KeyPair.fromSecret(this, secret);
};

EDDSA.prototype.makeSignature = function makeSignature(sig) {
  if (sig instanceof Signature) return sig;
  return new Signature(this, sig);
};
/**
* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2
*
* EDDSA defines methods for encoding and decoding points and integers. These are
* helper convenience methods, that pass along to utility functions implied
* parameters.
*
*/


EDDSA.prototype.encodePoint = function encodePoint(point) {
  var enc = point.getY().toArray('le', this.encodingLength);
  enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;
  return enc;
};

EDDSA.prototype.decodePoint = function decodePoint(bytes) {
  bytes = utils.parseBytes(bytes);
  var lastIx = bytes.length - 1;
  var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);
  var xIsOdd = (bytes[lastIx] & 0x80) !== 0;
  var y = utils.intFromLE(normed);
  return this.curve.pointFromY(y, xIsOdd);
};

EDDSA.prototype.encodeInt = function encodeInt(num) {
  return num.toArray('le', this.encodingLength);
};

EDDSA.prototype.decodeInt = function decodeInt(bytes) {
  return utils.intFromLE(bytes);
};

EDDSA.prototype.isPoint = function isPoint(val) {
  return val instanceof this.pointClass;
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/eddsa/key.js":
/*!*********************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/eddsa/key.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;
var parseBytes = utils.parseBytes;
var cachedProperty = utils.cachedProperty;
/**
* @param {EDDSA} eddsa - instance
* @param {Object} params - public/private key parameters
*
* @param {Array<Byte>} [params.secret] - secret seed bytes
* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)
* @param {Array<Byte>} [params.pub] - public key point encoded as bytes
*
*/

function KeyPair(eddsa, params) {
  this.eddsa = eddsa;
  this._secret = parseBytes(params.secret);
  if (eddsa.isPoint(params.pub)) this._pub = params.pub;else this._pubBytes = parseBytes(params.pub);
}

KeyPair.fromPublic = function fromPublic(eddsa, pub) {
  if (pub instanceof KeyPair) return pub;
  return new KeyPair(eddsa, {
    pub: pub
  });
};

KeyPair.fromSecret = function fromSecret(eddsa, secret) {
  if (secret instanceof KeyPair) return secret;
  return new KeyPair(eddsa, {
    secret: secret
  });
};

KeyPair.prototype.secret = function secret() {
  return this._secret;
};

cachedProperty(KeyPair, 'pubBytes', function pubBytes() {
  return this.eddsa.encodePoint(this.pub());
});
cachedProperty(KeyPair, 'pub', function pub() {
  if (this._pubBytes) return this.eddsa.decodePoint(this._pubBytes);
  return this.eddsa.g.mul(this.priv());
});
cachedProperty(KeyPair, 'privBytes', function privBytes() {
  var eddsa = this.eddsa;
  var hash = this.hash();
  var lastIx = eddsa.encodingLength - 1;
  var a = hash.slice(0, eddsa.encodingLength);
  a[0] &= 248;
  a[lastIx] &= 127;
  a[lastIx] |= 64;
  return a;
});
cachedProperty(KeyPair, 'priv', function priv() {
  return this.eddsa.decodeInt(this.privBytes());
});
cachedProperty(KeyPair, 'hash', function hash() {
  return this.eddsa.hash().update(this.secret()).digest();
});
cachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {
  return this.hash().slice(this.eddsa.encodingLength);
});

KeyPair.prototype.sign = function sign(message) {
  assert(this._secret, 'KeyPair can only verify');
  return this.eddsa.sign(message, this);
};

KeyPair.prototype.verify = function verify(message, sig) {
  return this.eddsa.verify(message, sig, this);
};

KeyPair.prototype.getSecret = function getSecret(enc) {
  assert(this._secret, 'KeyPair is public only');
  return utils.encode(this.secret(), enc);
};

KeyPair.prototype.getPublic = function getPublic(enc) {
  return utils.encode(this.pubBytes(), enc);
};

module.exports = KeyPair;

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/eddsa/signature.js":
/*!***************************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/eddsa/signature.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var utils = __webpack_require__(/*! ../utils */ "./node_modules/elliptic/lib/elliptic/utils.js");

var assert = utils.assert;
var cachedProperty = utils.cachedProperty;
var parseBytes = utils.parseBytes;
/**
* @param {EDDSA} eddsa - eddsa instance
* @param {Array<Bytes>|Object} sig -
* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes
* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes
* @param {Array<Bytes>} [sig.Rencoded] - R point encoded
* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded
*/

function Signature(eddsa, sig) {
  this.eddsa = eddsa;
  if (_typeof(sig) !== 'object') sig = parseBytes(sig);

  if (Array.isArray(sig)) {
    sig = {
      R: sig.slice(0, eddsa.encodingLength),
      S: sig.slice(eddsa.encodingLength)
    };
  }

  assert(sig.R && sig.S, 'Signature without R or S');
  if (eddsa.isPoint(sig.R)) this._R = sig.R;
  if (sig.S instanceof BN) this._S = sig.S;
  this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
  this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
}

cachedProperty(Signature, 'S', function S() {
  return this.eddsa.decodeInt(this.Sencoded());
});
cachedProperty(Signature, 'R', function R() {
  return this.eddsa.decodePoint(this.Rencoded());
});
cachedProperty(Signature, 'Rencoded', function Rencoded() {
  return this.eddsa.encodePoint(this.R());
});
cachedProperty(Signature, 'Sencoded', function Sencoded() {
  return this.eddsa.encodeInt(this.S());
});

Signature.prototype.toBytes = function toBytes() {
  return this.Rencoded().concat(this.Sencoded());
};

Signature.prototype.toHex = function toHex() {
  return utils.encode(this.toBytes(), 'hex').toUpperCase();
};

module.exports = Signature;

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js":
/*!*********************************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = {
  doubles: {
    step: 4,
    points: [['e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a', 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821'], ['8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508', '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf'], ['175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739', 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695'], ['363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640', '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9'], ['8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c', '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36'], ['723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda', '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f'], ['eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa', '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999'], ['100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0', 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09'], ['e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d', '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d'], ['feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d', 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088'], ['da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1', '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d'], ['53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0', '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8'], ['8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047', '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a'], ['385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862', '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453'], ['6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7', '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160'], ['3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd', '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0'], ['85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83', '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6'], ['948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a', '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589'], ['6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8', 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17'], ['e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d', '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda'], ['e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725', '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd'], ['213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754', '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2'], ['4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c', '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6'], ['fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6', '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f'], ['76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39', 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01'], ['c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891', '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3'], ['d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b', 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f'], ['b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03', '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7'], ['e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d', 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78'], ['a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070', '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1'], ['90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4', 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150'], ['8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da', '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82'], ['e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11', '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc'], ['8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e', 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b'], ['e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41', '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51'], ['b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef', '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45'], ['d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8', 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120'], ['324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d', '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84'], ['4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96', '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d'], ['9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd', 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d'], ['6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5', '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8'], ['a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266', '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8'], ['7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71', '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac'], ['928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac', 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f'], ['85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751', '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962'], ['ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e', '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907'], ['827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241', 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec'], ['eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3', 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d'], ['e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f', '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414'], ['1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19', 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd'], ['146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be', 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0'], ['fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9', '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811'], ['da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2', '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1'], ['a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13', '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c'], ['174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c', 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73'], ['959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba', '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd'], ['d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151', 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405'], ['64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073', 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589'], ['8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458', '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e'], ['13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b', '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27'], ['bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366', 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1'], ['8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa', '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482'], ['8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0', '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945'], ['dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787', '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573'], ['f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e', 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82']]
  },
  naf: {
    wnd: 7,
    points: [['f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9', '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672'], ['2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4', 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6'], ['5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc', '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da'], ['acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe', 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37'], ['774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb', 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b'], ['f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8', 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81'], ['d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e', '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58'], ['defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34', '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77'], ['2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c', '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a'], ['352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5', '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c'], ['2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f', '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67'], ['9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714', '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402'], ['daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729', 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55'], ['c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db', '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482'], ['6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4', 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82'], ['1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5', 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396'], ['605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479', '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49'], ['62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d', '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf'], ['80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f', '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a'], ['7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb', 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7'], ['d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9', 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933'], ['49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963', '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a'], ['77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74', '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6'], ['f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530', 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37'], ['463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b', '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e'], ['f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247', 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6'], ['caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1', 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476'], ['2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120', '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40'], ['7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435', '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61'], ['754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18', '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683'], ['e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8', '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5'], ['186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb', '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b'], ['df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f', '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417'], ['5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143', 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868'], ['290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba', 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a'], ['af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45', 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6'], ['766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a', '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996'], ['59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e', 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e'], ['f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8', 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d'], ['7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c', '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2'], ['948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519', 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e'], ['7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab', '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437'], ['3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca', 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311'], ['d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf', '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4'], ['1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610', '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575'], ['733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4', 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d'], ['15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c', 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d'], ['a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940', 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629'], ['e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980', 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06'], ['311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3', '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374'], ['34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf', '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee'], ['f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63', '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1'], ['d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448', 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b'], ['32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf', '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661'], ['7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5', '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6'], ['ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6', '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e'], ['16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5', '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d'], ['eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99', 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc'], ['78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51', 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4'], ['494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5', '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c'], ['a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5', '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b'], ['c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997', '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913'], ['841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881', '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154'], ['5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5', '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865'], ['36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66', 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc'], ['336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726', 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224'], ['8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede', '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e'], ['1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94', '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6'], ['85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31', '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511'], ['29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51', 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b'], ['a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252', 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2'], ['4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5', 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c'], ['d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b', '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3'], ['ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4', '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d'], ['af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f', '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700'], ['e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889', '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4'], ['591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246', 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196'], ['11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984', '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4'], ['3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a', 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257'], ['cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030', 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13'], ['c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197', '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096'], ['c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593', 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38'], ['a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef', '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f'], ['347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38', '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448'], ['da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a', '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a'], ['c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111', '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4'], ['4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502', '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437'], ['3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea', 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7'], ['cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26', '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d'], ['b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986', '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a'], ['d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e', '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54'], ['48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4', '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77'], ['dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda', 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517'], ['6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859', 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10'], ['e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f', 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125'], ['eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c', '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e'], ['13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942', 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1'], ['ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a', '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2'], ['b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80', '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423'], ['ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d', '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8'], ['8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1', 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758'], ['52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63', 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375'], ['e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352', '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d'], ['7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193', 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec'], ['5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00', '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0'], ['32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58', 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c'], ['e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7', 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4'], ['8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8', 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f'], ['4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e', '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649'], ['3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d', 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826'], ['674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b', '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5'], ['d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f', 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87'], ['30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6', '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b'], ['be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297', '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc'], ['93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a', '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c'], ['b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c', 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f'], ['d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52', '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a'], ['d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb', 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46'], ['463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065', 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f'], ['7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917', '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03'], ['74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9', 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08'], ['30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3', '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8'], ['9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57', '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373'], ['176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66', 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3'], ['75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8', '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8'], ['809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721', '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1'], ['1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180', '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9']]
  }
};

/***/ }),

/***/ "./node_modules/elliptic/lib/elliptic/utils.js":
/*!*****************************************************!*\
  !*** ./node_modules/elliptic/lib/elliptic/utils.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = exports;

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var minAssert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var minUtils = __webpack_require__(/*! minimalistic-crypto-utils */ "./node_modules/minimalistic-crypto-utils/lib/utils.js");

utils.assert = minAssert;
utils.toArray = minUtils.toArray;
utils.zero2 = minUtils.zero2;
utils.toHex = minUtils.toHex;
utils.encode = minUtils.encode; // Represent num in a w-NAF form

function getNAF(num, w, bits) {
  var naf = new Array(Math.max(num.bitLength(), bits) + 1);
  naf.fill(0);
  var ws = 1 << w + 1;
  var k = num.clone();

  for (var i = 0; i < naf.length; i++) {
    var z;
    var mod = k.andln(ws - 1);

    if (k.isOdd()) {
      if (mod > (ws >> 1) - 1) z = (ws >> 1) - mod;else z = mod;
      k.isubn(z);
    } else {
      z = 0;
    }

    naf[i] = z;
    k.iushrn(1);
  }

  return naf;
}

utils.getNAF = getNAF; // Represent k1, k2 in a Joint Sparse Form

function getJSF(k1, k2) {
  var jsf = [[], []];
  k1 = k1.clone();
  k2 = k2.clone();
  var d1 = 0;
  var d2 = 0;

  while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
    // First phase
    var m14 = k1.andln(3) + d1 & 3;
    var m24 = k2.andln(3) + d2 & 3;
    if (m14 === 3) m14 = -1;
    if (m24 === 3) m24 = -1;
    var u1;

    if ((m14 & 1) === 0) {
      u1 = 0;
    } else {
      var m8 = k1.andln(7) + d1 & 7;
      if ((m8 === 3 || m8 === 5) && m24 === 2) u1 = -m14;else u1 = m14;
    }

    jsf[0].push(u1);
    var u2;

    if ((m24 & 1) === 0) {
      u2 = 0;
    } else {
      var m8 = k2.andln(7) + d2 & 7;
      if ((m8 === 3 || m8 === 5) && m14 === 2) u2 = -m24;else u2 = m24;
    }

    jsf[1].push(u2); // Second phase

    if (2 * d1 === u1 + 1) d1 = 1 - d1;
    if (2 * d2 === u2 + 1) d2 = 1 - d2;
    k1.iushrn(1);
    k2.iushrn(1);
  }

  return jsf;
}

utils.getJSF = getJSF;

function cachedProperty(obj, name, computer) {
  var key = '_' + name;

  obj.prototype[name] = function cachedProperty() {
    return this[key] !== undefined ? this[key] : this[key] = computer.call(this);
  };
}

utils.cachedProperty = cachedProperty;

function parseBytes(bytes) {
  return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') : bytes;
}

utils.parseBytes = parseBytes;

function intFromLE(bytes) {
  return new BN(bytes, 'hex', 'le');
}

utils.intFromLE = intFromLE;

/***/ }),

/***/ "./node_modules/elliptic/package.json":
/*!********************************************!*\
  !*** ./node_modules/elliptic/package.json ***!
  \********************************************/
/*! exports provided: _args, _from, _id, _inBundle, _integrity, _location, _phantomChildren, _requested, _requiredBy, _resolved, _spec, _where, author, bugs, dependencies, description, devDependencies, files, homepage, keywords, license, main, name, repository, scripts, version, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"_args\":[[\"elliptic@6.5.2\",\"/Users/mo/Desktop/sn/dev/snjs\"]],\"_from\":\"elliptic@6.5.2\",\"_id\":\"elliptic@6.5.2\",\"_inBundle\":false,\"_integrity\":\"sha512-f4x70okzZbIQl/NSRLkI/+tteV/9WqL98zx+SQ69KbXxmVrmjwsNUPn/gYJJ0sHvEak24cZgHIPegRePAtA/xw==\",\"_location\":\"/sncrypto/elliptic\",\"_phantomChildren\":{},\"_requested\":{\"type\":\"version\",\"registry\":true,\"raw\":\"elliptic@6.5.2\",\"name\":\"elliptic\",\"escapedName\":\"elliptic\",\"rawSpec\":\"6.5.2\",\"saveSpec\":null,\"fetchSpec\":\"6.5.2\"},\"_requiredBy\":[\"/sncrypto/browserify-sign\",\"/sncrypto/create-ecdh\"],\"_resolved\":\"https://registry.npmjs.org/elliptic/-/elliptic-6.5.2.tgz\",\"_spec\":\"6.5.2\",\"_where\":\"/Users/mo/Desktop/sn/dev/snjs\",\"author\":{\"name\":\"Fedor Indutny\",\"email\":\"fedor@indutny.com\"},\"bugs\":{\"url\":\"https://github.com/indutny/elliptic/issues\"},\"dependencies\":{\"bn.js\":\"^4.4.0\",\"brorand\":\"^1.0.1\",\"hash.js\":\"^1.0.0\",\"hmac-drbg\":\"^1.0.0\",\"inherits\":\"^2.0.1\",\"minimalistic-assert\":\"^1.0.0\",\"minimalistic-crypto-utils\":\"^1.0.0\"},\"description\":\"EC cryptography\",\"devDependencies\":{\"brfs\":\"^1.4.3\",\"coveralls\":\"^3.0.8\",\"grunt\":\"^1.0.4\",\"grunt-browserify\":\"^5.0.0\",\"grunt-cli\":\"^1.2.0\",\"grunt-contrib-connect\":\"^1.0.0\",\"grunt-contrib-copy\":\"^1.0.0\",\"grunt-contrib-uglify\":\"^1.0.1\",\"grunt-mocha-istanbul\":\"^3.0.1\",\"grunt-saucelabs\":\"^9.0.1\",\"istanbul\":\"^0.4.2\",\"jscs\":\"^3.0.7\",\"jshint\":\"^2.10.3\",\"mocha\":\"^6.2.2\"},\"files\":[\"lib\"],\"homepage\":\"https://github.com/indutny/elliptic\",\"keywords\":[\"EC\",\"Elliptic\",\"curve\",\"Cryptography\"],\"license\":\"MIT\",\"main\":\"lib/elliptic.js\",\"name\":\"elliptic\",\"repository\":{\"type\":\"git\",\"url\":\"git+ssh://git@github.com/indutny/elliptic.git\"},\"scripts\":{\"jscs\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"jshint\":\"jscs benchmarks/*.js lib/*.js lib/**/*.js lib/**/**/*.js test/index.js\",\"lint\":\"npm run jscs && npm run jshint\",\"test\":\"npm run lint && npm run unit\",\"unit\":\"istanbul test _mocha --reporter=spec test/index.js\",\"version\":\"grunt dist && git add dist/\"},\"version\":\"6.5.2\"}");

/***/ }),

/***/ "./node_modules/events/events.js":
/*!***************************************!*\
  !*** ./node_modules/events/events.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 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.


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var R = (typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === 'object' ? Reflect : null;
var ReflectApply = R && typeof R.apply === 'function' ? R.apply : function ReflectApply(target, receiver, args) {
  return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys;

if (R && typeof R.ownKeys === 'function') {
  ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
  ReflectOwnKeys = function ReflectOwnKeys(target) {
    return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
  };
} else {
  ReflectOwnKeys = function ReflectOwnKeys(target) {
    return Object.getOwnPropertyNames(target);
  };
}

function ProcessEmitWarning(warning) {
  if (console && console.warn) console.warn(warning);
}

var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
  return value !== value;
};

function EventEmitter() {
  EventEmitter.init.call(this);
}

module.exports = EventEmitter; // Backwards-compat with node 0.10.x

EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
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;

function checkListener(listener) {
  if (typeof listener !== 'function') {
    throw new TypeError('The "listener" argument must be of type Function. Received type ' + _typeof(listener));
  }
}

Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
  enumerable: true,
  get: function get() {
    return defaultMaxListeners;
  },
  set: function set(arg) {
    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
    }

    defaultMaxListeners = arg;
  }
});

EventEmitter.init = function () {
  if (this._events === undefined || this._events === Object.getPrototypeOf(this)._events) {
    this._events = Object.create(null);
    this._eventsCount = 0;
  }

  this._maxListeners = this._maxListeners || undefined;
}; // 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 || NumberIsNaN(n)) {
    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
  }

  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);
};

EventEmitter.prototype.emit = function emit(type) {
  var args = [];

  for (var i = 1; i < arguments.length; i++) {
    args.push(arguments[i]);
  }

  var doError = type === 'error';
  var events = this._events;
  if (events !== undefined) doError = doError && events.error === undefined;else if (!doError) return false; // If there is no 'error' event listener then throw.

  if (doError) {
    var er;
    if (args.length > 0) er = args[0];

    if (er instanceof Error) {
      // Note: The comments on the `throw` lines are intentional, they show
      // up in Node's output if this results in an unhandled exception.
      throw er; // Unhandled 'error' event
    } // At least give some kind of context to the user


    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
    err.context = er;
    throw err; // Unhandled 'error' event
  }

  var handler = events[type];
  if (handler === undefined) return false;

  if (typeof handler === 'function') {
    ReflectApply(handler, this, args);
  } else {
    var len = handler.length;
    var listeners = arrayClone(handler, len);

    for (var i = 0; i < len; ++i) {
      ReflectApply(listeners[i], this, args);
    }
  }

  return true;
};

function _addListener(target, type, listener, prepend) {
  var m;
  var events;
  var existing;
  checkListener(listener);
  events = target._events;

  if (events === undefined) {
    events = target._events = Object.create(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 !== undefined) {
      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 === undefined) {
    // 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]; // If we've already got an array, just append.
    } else if (prepend) {
      existing.unshift(listener);
    } else {
      existing.push(listener);
    } // Check for listener leak


    m = _getMaxListeners(target);

    if (m > 0 && existing.length > m && !existing.warned) {
      existing.warned = true; // No error code for this since it is a Warning
      // eslint-disable-next-line no-restricted-syntax

      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;
      ProcessEmitWarning(w);
    }
  }

  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;
    if (arguments.length === 0) return this.listener.call(this.target);
    return this.listener.apply(this.target, arguments);
  }
}

function _onceWrap(target, type, listener) {
  var state = {
    fired: false,
    wrapFn: undefined,
    target: target,
    type: type,
    listener: listener
  };
  var wrapped = onceWrapper.bind(state);
  wrapped.listener = listener;
  state.wrapFn = wrapped;
  return wrapped;
}

EventEmitter.prototype.once = function once(type, listener) {
  checkListener(listener);
  this.on(type, _onceWrap(this, type, listener));
  return this;
};

EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
  checkListener(listener);
  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;
  checkListener(listener);
  events = this._events;
  if (events === undefined) return this;
  list = events[type];
  if (list === undefined) return this;

  if (list === listener || list.listener === listener) {
    if (--this._eventsCount === 0) this._events = Object.create(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 !== undefined) this.emit('removeListener', type, originalListener || listener);
  }

  return this;
};

EventEmitter.prototype.off = EventEmitter.prototype.removeListener;

EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
  var listeners, events, i;
  events = this._events;
  if (events === undefined) return this; // not listening for removeListener, no need to emit

  if (events.removeListener === undefined) {
    if (arguments.length === 0) {
      this._events = Object.create(null);
      this._eventsCount = 0;
    } else if (events[type] !== undefined) {
      if (--this._eventsCount === 0) this._events = Object.create(null);else delete events[type];
    }

    return this;
  } // emit removeListener for all listeners on all events


  if (arguments.length === 0) {
    var keys = Object.keys(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 = Object.create(null);
    this._eventsCount = 0;
    return this;
  }

  listeners = events[type];

  if (typeof listeners === 'function') {
    this.removeListener(type, listeners);
  } else if (listeners !== undefined) {
    // 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 === undefined) return [];
  var evlistener = events[type];
  if (evlistener === undefined) 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 !== undefined) {
    var evlistener = events[type];

    if (typeof evlistener === 'function') {
      return 1;
    } else if (evlistener !== undefined) {
      return evlistener.length;
    }
  }

  return 0;
}

EventEmitter.prototype.eventNames = function eventNames() {
  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};

function arrayClone(arr, n) {
  var copy = new Array(n);

  for (var i = 0; i < n; ++i) {
    copy[i] = arr[i];
  }

  return copy;
}

function spliceOne(list, index) {
  for (; index + 1 < list.length; index++) {
    list[index] = list[index + 1];
  }

  list.pop();
}

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;
}

/***/ }),

/***/ "./node_modules/evp_bytestokey/index.js":
/*!**********************************************!*\
  !*** ./node_modules/evp_bytestokey/index.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var MD5 = __webpack_require__(/*! md5.js */ "./node_modules/md5.js/index.js");
/* eslint-disable camelcase */


function EVP_BytesToKey(password, salt, keyBits, ivLen) {
  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary');

  if (salt) {
    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary');
    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length');
  }

  var keyLen = keyBits / 8;
  var key = Buffer.alloc(keyLen);
  var iv = Buffer.alloc(ivLen || 0);
  var tmp = Buffer.alloc(0);

  while (keyLen > 0 || ivLen > 0) {
    var hash = new MD5();
    hash.update(tmp);
    hash.update(password);
    if (salt) hash.update(salt);
    tmp = hash.digest();
    var used = 0;

    if (keyLen > 0) {
      var keyStart = key.length - keyLen;
      used = Math.min(keyLen, tmp.length);
      tmp.copy(key, keyStart, 0, used);
      keyLen -= used;
    }

    if (used < tmp.length && ivLen > 0) {
      var ivStart = iv.length - ivLen;
      var length = Math.min(ivLen, tmp.length - used);
      tmp.copy(iv, ivStart, used, used + length);
      ivLen -= length;
    }
  }

  tmp.fill(0);
  return {
    key: key,
    iv: iv
  };
}

module.exports = EVP_BytesToKey;

/***/ }),

/***/ "./node_modules/hash-base/index.js":
/*!*****************************************!*\
  !*** ./node_modules/hash-base/index.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var Transform = __webpack_require__(/*! stream */ "./node_modules/stream-browserify/index.js").Transform;

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

function throwIfNotStringOrBuffer(val, prefix) {
  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
    throw new TypeError(prefix + ' must be a string or a buffer');
  }
}

function HashBase(blockSize) {
  Transform.call(this);
  this._block = Buffer.allocUnsafe(blockSize);
  this._blockSize = blockSize;
  this._blockOffset = 0;
  this._length = [0, 0, 0, 0];
  this._finalized = false;
}

inherits(HashBase, Transform);

HashBase.prototype._transform = function (chunk, encoding, callback) {
  var error = null;

  try {
    this.update(chunk, encoding);
  } catch (err) {
    error = err;
  }

  callback(error);
};

HashBase.prototype._flush = function (callback) {
  var error = null;

  try {
    this.push(this.digest());
  } catch (err) {
    error = err;
  }

  callback(error);
};

HashBase.prototype.update = function (data, encoding) {
  throwIfNotStringOrBuffer(data, 'Data');
  if (this._finalized) throw new Error('Digest already called');
  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding); // consume data

  var block = this._block;
  var offset = 0;

  while (this._blockOffset + data.length - offset >= this._blockSize) {
    for (var i = this._blockOffset; i < this._blockSize;) {
      block[i++] = data[offset++];
    }

    this._update();

    this._blockOffset = 0;
  }

  while (offset < data.length) {
    block[this._blockOffset++] = data[offset++];
  } // update length


  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
    this._length[j] += carry;
    carry = this._length[j] / 0x0100000000 | 0;
    if (carry > 0) this._length[j] -= 0x0100000000 * carry;
  }

  return this;
};

HashBase.prototype._update = function () {
  throw new Error('_update is not implemented');
};

HashBase.prototype.digest = function (encoding) {
  if (this._finalized) throw new Error('Digest already called');
  this._finalized = true;

  var digest = this._digest();

  if (encoding !== undefined) digest = digest.toString(encoding); // reset state

  this._block.fill(0);

  this._blockOffset = 0;

  for (var i = 0; i < 4; ++i) {
    this._length[i] = 0;
  }

  return digest;
};

HashBase.prototype._digest = function () {
  throw new Error('_digest is not implemented');
};

module.exports = HashBase;

/***/ }),

/***/ "./node_modules/hash.js/lib/hash.js":
/*!******************************************!*\
  !*** ./node_modules/hash.js/lib/hash.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var hash = exports;
hash.utils = __webpack_require__(/*! ./hash/utils */ "./node_modules/hash.js/lib/hash/utils.js");
hash.common = __webpack_require__(/*! ./hash/common */ "./node_modules/hash.js/lib/hash/common.js");
hash.sha = __webpack_require__(/*! ./hash/sha */ "./node_modules/hash.js/lib/hash/sha.js");
hash.ripemd = __webpack_require__(/*! ./hash/ripemd */ "./node_modules/hash.js/lib/hash/ripemd.js");
hash.hmac = __webpack_require__(/*! ./hash/hmac */ "./node_modules/hash.js/lib/hash/hmac.js"); // Proxy hash functions to the main object

hash.sha1 = hash.sha.sha1;
hash.sha256 = hash.sha.sha256;
hash.sha224 = hash.sha.sha224;
hash.sha384 = hash.sha.sha384;
hash.sha512 = hash.sha.sha512;
hash.ripemd160 = hash.ripemd.ripemd160;

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/common.js":
/*!*************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/common.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ./utils */ "./node_modules/hash.js/lib/hash/utils.js");

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

function BlockHash() {
  this.pending = null;
  this.pendingTotal = 0;
  this.blockSize = this.constructor.blockSize;
  this.outSize = this.constructor.outSize;
  this.hmacStrength = this.constructor.hmacStrength;
  this.padLength = this.constructor.padLength / 8;
  this.endian = 'big';
  this._delta8 = this.blockSize / 8;
  this._delta32 = this.blockSize / 32;
}

exports.BlockHash = BlockHash;

BlockHash.prototype.update = function update(msg, enc) {
  // Convert message to array, pad it, and join into 32bit blocks
  msg = utils.toArray(msg, enc);
  if (!this.pending) this.pending = msg;else this.pending = this.pending.concat(msg);
  this.pendingTotal += msg.length; // Enough data, try updating

  if (this.pending.length >= this._delta8) {
    msg = this.pending; // Process pending data in blocks

    var r = msg.length % this._delta8;
    this.pending = msg.slice(msg.length - r, msg.length);
    if (this.pending.length === 0) this.pending = null;
    msg = utils.join32(msg, 0, msg.length - r, this.endian);

    for (var i = 0; i < msg.length; i += this._delta32) {
      this._update(msg, i, i + this._delta32);
    }
  }

  return this;
};

BlockHash.prototype.digest = function digest(enc) {
  this.update(this._pad());
  assert(this.pending === null);
  return this._digest(enc);
};

BlockHash.prototype._pad = function pad() {
  var len = this.pendingTotal;
  var bytes = this._delta8;
  var k = bytes - (len + this.padLength) % bytes;
  var res = new Array(k + this.padLength);
  res[0] = 0x80;

  for (var i = 1; i < k; i++) {
    res[i] = 0;
  } // Append length


  len <<= 3;

  if (this.endian === 'big') {
    for (var t = 8; t < this.padLength; t++) {
      res[i++] = 0;
    }

    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = len >>> 24 & 0xff;
    res[i++] = len >>> 16 & 0xff;
    res[i++] = len >>> 8 & 0xff;
    res[i++] = len & 0xff;
  } else {
    res[i++] = len & 0xff;
    res[i++] = len >>> 8 & 0xff;
    res[i++] = len >>> 16 & 0xff;
    res[i++] = len >>> 24 & 0xff;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;
    res[i++] = 0;

    for (t = 8; t < this.padLength; t++) {
      res[i++] = 0;
    }
  }

  return res;
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/hmac.js":
/*!***********************************************!*\
  !*** ./node_modules/hash.js/lib/hash/hmac.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ./utils */ "./node_modules/hash.js/lib/hash/utils.js");

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

function Hmac(hash, key, enc) {
  if (!(this instanceof Hmac)) return new Hmac(hash, key, enc);
  this.Hash = hash;
  this.blockSize = hash.blockSize / 8;
  this.outSize = hash.outSize / 8;
  this.inner = null;
  this.outer = null;

  this._init(utils.toArray(key, enc));
}

module.exports = Hmac;

Hmac.prototype._init = function init(key) {
  // Shorten key, if needed
  if (key.length > this.blockSize) key = new this.Hash().update(key).digest();
  assert(key.length <= this.blockSize); // Add padding to key

  for (var i = key.length; i < this.blockSize; i++) {
    key.push(0);
  }

  for (i = 0; i < key.length; i++) {
    key[i] ^= 0x36;
  }

  this.inner = new this.Hash().update(key); // 0x36 ^ 0x5c = 0x6a

  for (i = 0; i < key.length; i++) {
    key[i] ^= 0x6a;
  }

  this.outer = new this.Hash().update(key);
};

Hmac.prototype.update = function update(msg, enc) {
  this.inner.update(msg, enc);
  return this;
};

Hmac.prototype.digest = function digest(enc) {
  this.outer.update(this.inner.digest());
  return this.outer.digest(enc);
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/ripemd.js":
/*!*************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/ripemd.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ./utils */ "./node_modules/hash.js/lib/hash/utils.js");

var common = __webpack_require__(/*! ./common */ "./node_modules/hash.js/lib/hash/common.js");

var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_3 = utils.sum32_3;
var sum32_4 = utils.sum32_4;
var BlockHash = common.BlockHash;

function RIPEMD160() {
  if (!(this instanceof RIPEMD160)) return new RIPEMD160();
  BlockHash.call(this);
  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  this.endian = 'little';
}

utils.inherits(RIPEMD160, BlockHash);
exports.ripemd160 = RIPEMD160;
RIPEMD160.blockSize = 512;
RIPEMD160.outSize = 160;
RIPEMD160.hmacStrength = 192;
RIPEMD160.padLength = 64;

RIPEMD160.prototype._update = function update(msg, start) {
  var A = this.h[0];
  var B = this.h[1];
  var C = this.h[2];
  var D = this.h[3];
  var E = this.h[4];
  var Ah = A;
  var Bh = B;
  var Ch = C;
  var Dh = D;
  var Eh = E;

  for (var j = 0; j < 80; j++) {
    var T = sum32(rotl32(sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)), s[j]), E);
    A = E;
    E = D;
    D = rotl32(C, 10);
    C = B;
    B = T;
    T = sum32(rotl32(sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)), sh[j]), Eh);
    Ah = Eh;
    Eh = Dh;
    Dh = rotl32(Ch, 10);
    Ch = Bh;
    Bh = T;
  }

  T = sum32_3(this.h[1], C, Dh);
  this.h[1] = sum32_3(this.h[2], D, Eh);
  this.h[2] = sum32_3(this.h[3], E, Ah);
  this.h[3] = sum32_3(this.h[4], A, Bh);
  this.h[4] = sum32_3(this.h[0], B, Ch);
  this.h[0] = T;
};

RIPEMD160.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'little');else return utils.split32(this.h, 'little');
};

function f(j, x, y, z) {
  if (j <= 15) return x ^ y ^ z;else if (j <= 31) return x & y | ~x & z;else if (j <= 47) return (x | ~y) ^ z;else if (j <= 63) return x & z | y & ~z;else return x ^ (y | ~z);
}

function K(j) {
  if (j <= 15) return 0x00000000;else if (j <= 31) return 0x5a827999;else if (j <= 47) return 0x6ed9eba1;else if (j <= 63) return 0x8f1bbcdc;else return 0xa953fd4e;
}

function Kh(j) {
  if (j <= 15) return 0x50a28be6;else if (j <= 31) return 0x5c4dd124;else if (j <= 47) return 0x6d703ef3;else if (j <= 63) return 0x7a6d76e9;else return 0x00000000;
}

var r = [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 rh = [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 s = [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 sh = [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];

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha.js":
/*!**********************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.sha1 = __webpack_require__(/*! ./sha/1 */ "./node_modules/hash.js/lib/hash/sha/1.js");
exports.sha224 = __webpack_require__(/*! ./sha/224 */ "./node_modules/hash.js/lib/hash/sha/224.js");
exports.sha256 = __webpack_require__(/*! ./sha/256 */ "./node_modules/hash.js/lib/hash/sha/256.js");
exports.sha384 = __webpack_require__(/*! ./sha/384 */ "./node_modules/hash.js/lib/hash/sha/384.js");
exports.sha512 = __webpack_require__(/*! ./sha/512 */ "./node_modules/hash.js/lib/hash/sha/512.js");

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/1.js":
/*!************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/1.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var common = __webpack_require__(/*! ../common */ "./node_modules/hash.js/lib/hash/common.js");

var shaCommon = __webpack_require__(/*! ./common */ "./node_modules/hash.js/lib/hash/sha/common.js");

var rotl32 = utils.rotl32;
var sum32 = utils.sum32;
var sum32_5 = utils.sum32_5;
var ft_1 = shaCommon.ft_1;
var BlockHash = common.BlockHash;
var sha1_K = [0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6];

function SHA1() {
  if (!(this instanceof SHA1)) return new SHA1();
  BlockHash.call(this);
  this.h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  this.W = new Array(80);
}

utils.inherits(SHA1, BlockHash);
module.exports = SHA1;
SHA1.blockSize = 512;
SHA1.outSize = 160;
SHA1.hmacStrength = 80;
SHA1.padLength = 64;

SHA1.prototype._update = function _update(msg, start) {
  var W = this.W;

  for (var i = 0; i < 16; i++) {
    W[i] = msg[start + i];
  }

  for (; i < W.length; i++) {
    W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
  }

  var a = this.h[0];
  var b = this.h[1];
  var c = this.h[2];
  var d = this.h[3];
  var e = this.h[4];

  for (i = 0; i < W.length; i++) {
    var s = ~~(i / 20);
    var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
    e = d;
    d = c;
    c = rotl32(b, 30);
    b = a;
    a = t;
  }

  this.h[0] = sum32(this.h[0], a);
  this.h[1] = sum32(this.h[1], b);
  this.h[2] = sum32(this.h[2], c);
  this.h[3] = sum32(this.h[3], d);
  this.h[4] = sum32(this.h[4], e);
};

SHA1.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/224.js":
/*!**************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/224.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var SHA256 = __webpack_require__(/*! ./256 */ "./node_modules/hash.js/lib/hash/sha/256.js");

function SHA224() {
  if (!(this instanceof SHA224)) return new SHA224();
  SHA256.call(this);
  this.h = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
}

utils.inherits(SHA224, SHA256);
module.exports = SHA224;
SHA224.blockSize = 512;
SHA224.outSize = 224;
SHA224.hmacStrength = 192;
SHA224.padLength = 64;

SHA224.prototype._digest = function digest(enc) {
  // Just truncate output
  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 7), 'big');else return utils.split32(this.h.slice(0, 7), 'big');
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/256.js":
/*!**************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/256.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var common = __webpack_require__(/*! ../common */ "./node_modules/hash.js/lib/hash/common.js");

var shaCommon = __webpack_require__(/*! ./common */ "./node_modules/hash.js/lib/hash/sha/common.js");

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var sum32 = utils.sum32;
var sum32_4 = utils.sum32_4;
var sum32_5 = utils.sum32_5;
var ch32 = shaCommon.ch32;
var maj32 = shaCommon.maj32;
var s0_256 = shaCommon.s0_256;
var s1_256 = shaCommon.s1_256;
var g0_256 = shaCommon.g0_256;
var g1_256 = shaCommon.g1_256;
var BlockHash = common.BlockHash;
var sha256_K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];

function SHA256() {
  if (!(this instanceof SHA256)) return new SHA256();
  BlockHash.call(this);
  this.h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
  this.k = sha256_K;
  this.W = new Array(64);
}

utils.inherits(SHA256, BlockHash);
module.exports = SHA256;
SHA256.blockSize = 512;
SHA256.outSize = 256;
SHA256.hmacStrength = 192;
SHA256.padLength = 64;

SHA256.prototype._update = function _update(msg, start) {
  var W = this.W;

  for (var i = 0; i < 16; i++) {
    W[i] = msg[start + i];
  }

  for (; i < W.length; i++) {
    W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
  }

  var a = this.h[0];
  var b = this.h[1];
  var c = this.h[2];
  var d = this.h[3];
  var e = this.h[4];
  var f = this.h[5];
  var g = this.h[6];
  var h = this.h[7];
  assert(this.k.length === W.length);

  for (i = 0; i < W.length; i++) {
    var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);
    var T2 = sum32(s0_256(a), maj32(a, b, c));
    h = g;
    g = f;
    f = e;
    e = sum32(d, T1);
    d = c;
    c = b;
    b = a;
    a = sum32(T1, T2);
  }

  this.h[0] = sum32(this.h[0], a);
  this.h[1] = sum32(this.h[1], b);
  this.h[2] = sum32(this.h[2], c);
  this.h[3] = sum32(this.h[3], d);
  this.h[4] = sum32(this.h[4], e);
  this.h[5] = sum32(this.h[5], f);
  this.h[6] = sum32(this.h[6], g);
  this.h[7] = sum32(this.h[7], h);
};

SHA256.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/384.js":
/*!**************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/384.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var SHA512 = __webpack_require__(/*! ./512 */ "./node_modules/hash.js/lib/hash/sha/512.js");

function SHA384() {
  if (!(this instanceof SHA384)) return new SHA384();
  SHA512.call(this);
  this.h = [0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939, 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4];
}

utils.inherits(SHA384, SHA512);
module.exports = SHA384;
SHA384.blockSize = 1024;
SHA384.outSize = 384;
SHA384.hmacStrength = 192;
SHA384.padLength = 128;

SHA384.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h.slice(0, 12), 'big');else return utils.split32(this.h.slice(0, 12), 'big');
};

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/512.js":
/*!**************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/512.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var common = __webpack_require__(/*! ../common */ "./node_modules/hash.js/lib/hash/common.js");

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var rotr64_hi = utils.rotr64_hi;
var rotr64_lo = utils.rotr64_lo;
var shr64_hi = utils.shr64_hi;
var shr64_lo = utils.shr64_lo;
var sum64 = utils.sum64;
var sum64_hi = utils.sum64_hi;
var sum64_lo = utils.sum64_lo;
var sum64_4_hi = utils.sum64_4_hi;
var sum64_4_lo = utils.sum64_4_lo;
var sum64_5_hi = utils.sum64_5_hi;
var sum64_5_lo = utils.sum64_5_lo;
var BlockHash = common.BlockHash;
var sha512_K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];

function SHA512() {
  if (!(this instanceof SHA512)) return new SHA512();
  BlockHash.call(this);
  this.h = [0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179];
  this.k = sha512_K;
  this.W = new Array(160);
}

utils.inherits(SHA512, BlockHash);
module.exports = SHA512;
SHA512.blockSize = 1024;
SHA512.outSize = 512;
SHA512.hmacStrength = 192;
SHA512.padLength = 128;

SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
  var W = this.W; // 32 x 32bit words

  for (var i = 0; i < 32; i++) {
    W[i] = msg[start + i];
  }

  for (; i < W.length; i += 2) {
    var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2

    var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
    var c1_hi = W[i - 14]; // i - 7

    var c1_lo = W[i - 13];
    var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15

    var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
    var c3_hi = W[i - 32]; // i - 16

    var c3_lo = W[i - 31];
    W[i] = sum64_4_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
    W[i + 1] = sum64_4_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo);
  }
};

SHA512.prototype._update = function _update(msg, start) {
  this._prepareBlock(msg, start);

  var W = this.W;
  var ah = this.h[0];
  var al = this.h[1];
  var bh = this.h[2];
  var bl = this.h[3];
  var ch = this.h[4];
  var cl = this.h[5];
  var dh = this.h[6];
  var dl = this.h[7];
  var eh = this.h[8];
  var el = this.h[9];
  var fh = this.h[10];
  var fl = this.h[11];
  var gh = this.h[12];
  var gl = this.h[13];
  var hh = this.h[14];
  var hl = this.h[15];
  assert(this.k.length === W.length);

  for (var i = 0; i < W.length; i += 2) {
    var c0_hi = hh;
    var c0_lo = hl;
    var c1_hi = s1_512_hi(eh, el);
    var c1_lo = s1_512_lo(eh, el);
    var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
    var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
    var c3_hi = this.k[i];
    var c3_lo = this.k[i + 1];
    var c4_hi = W[i];
    var c4_lo = W[i + 1];
    var T1_hi = sum64_5_hi(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
    var T1_lo = sum64_5_lo(c0_hi, c0_lo, c1_hi, c1_lo, c2_hi, c2_lo, c3_hi, c3_lo, c4_hi, c4_lo);
    c0_hi = s0_512_hi(ah, al);
    c0_lo = s0_512_lo(ah, al);
    c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
    c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
    var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
    var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
    hh = gh;
    hl = gl;
    gh = fh;
    gl = fl;
    fh = eh;
    fl = el;
    eh = sum64_hi(dh, dl, T1_hi, T1_lo);
    el = sum64_lo(dl, dl, T1_hi, T1_lo);
    dh = ch;
    dl = cl;
    ch = bh;
    cl = bl;
    bh = ah;
    bl = al;
    ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
    al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
  }

  sum64(this.h, 0, ah, al);
  sum64(this.h, 2, bh, bl);
  sum64(this.h, 4, ch, cl);
  sum64(this.h, 6, dh, dl);
  sum64(this.h, 8, eh, el);
  sum64(this.h, 10, fh, fl);
  sum64(this.h, 12, gh, gl);
  sum64(this.h, 14, hh, hl);
};

SHA512.prototype._digest = function digest(enc) {
  if (enc === 'hex') return utils.toHex32(this.h, 'big');else return utils.split32(this.h, 'big');
};

function ch64_hi(xh, xl, yh, yl, zh) {
  var r = xh & yh ^ ~xh & zh;
  if (r < 0) r += 0x100000000;
  return r;
}

function ch64_lo(xh, xl, yh, yl, zh, zl) {
  var r = xl & yl ^ ~xl & zl;
  if (r < 0) r += 0x100000000;
  return r;
}

function maj64_hi(xh, xl, yh, yl, zh) {
  var r = xh & yh ^ xh & zh ^ yh & zh;
  if (r < 0) r += 0x100000000;
  return r;
}

function maj64_lo(xh, xl, yh, yl, zh, zl) {
  var r = xl & yl ^ xl & zl ^ yl & zl;
  if (r < 0) r += 0x100000000;
  return r;
}

function s0_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 28);
  var c1_hi = rotr64_hi(xl, xh, 2); // 34

  var c2_hi = rotr64_hi(xl, xh, 7); // 39

  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}

function s0_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 28);
  var c1_lo = rotr64_lo(xl, xh, 2); // 34

  var c2_lo = rotr64_lo(xl, xh, 7); // 39

  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}

function s1_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 14);
  var c1_hi = rotr64_hi(xh, xl, 18);
  var c2_hi = rotr64_hi(xl, xh, 9); // 41

  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}

function s1_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 14);
  var c1_lo = rotr64_lo(xh, xl, 18);
  var c2_lo = rotr64_lo(xl, xh, 9); // 41

  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}

function g0_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 1);
  var c1_hi = rotr64_hi(xh, xl, 8);
  var c2_hi = shr64_hi(xh, xl, 7);
  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}

function g0_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 1);
  var c1_lo = rotr64_lo(xh, xl, 8);
  var c2_lo = shr64_lo(xh, xl, 7);
  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}

function g1_512_hi(xh, xl) {
  var c0_hi = rotr64_hi(xh, xl, 19);
  var c1_hi = rotr64_hi(xl, xh, 29); // 61

  var c2_hi = shr64_hi(xh, xl, 6);
  var r = c0_hi ^ c1_hi ^ c2_hi;
  if (r < 0) r += 0x100000000;
  return r;
}

function g1_512_lo(xh, xl) {
  var c0_lo = rotr64_lo(xh, xl, 19);
  var c1_lo = rotr64_lo(xl, xh, 29); // 61

  var c2_lo = shr64_lo(xh, xl, 6);
  var r = c0_lo ^ c1_lo ^ c2_lo;
  if (r < 0) r += 0x100000000;
  return r;
}

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/sha/common.js":
/*!*****************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/sha/common.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(/*! ../utils */ "./node_modules/hash.js/lib/hash/utils.js");

var rotr32 = utils.rotr32;

function ft_1(s, x, y, z) {
  if (s === 0) return ch32(x, y, z);
  if (s === 1 || s === 3) return p32(x, y, z);
  if (s === 2) return maj32(x, y, z);
}

exports.ft_1 = ft_1;

function ch32(x, y, z) {
  return x & y ^ ~x & z;
}

exports.ch32 = ch32;

function maj32(x, y, z) {
  return x & y ^ x & z ^ y & z;
}

exports.maj32 = maj32;

function p32(x, y, z) {
  return x ^ y ^ z;
}

exports.p32 = p32;

function s0_256(x) {
  return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
}

exports.s0_256 = s0_256;

function s1_256(x) {
  return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
}

exports.s1_256 = s1_256;

function g0_256(x) {
  return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
}

exports.g0_256 = g0_256;

function g1_256(x) {
  return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
}

exports.g1_256 = g1_256;

/***/ }),

/***/ "./node_modules/hash.js/lib/hash/utils.js":
/*!************************************************!*\
  !*** ./node_modules/hash.js/lib/hash/utils.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

exports.inherits = inherits;

function isSurrogatePair(msg, i) {
  if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {
    return false;
  }

  if (i < 0 || i + 1 >= msg.length) {
    return false;
  }

  return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;
}

function toArray(msg, enc) {
  if (Array.isArray(msg)) return msg.slice();
  if (!msg) return [];
  var res = [];

  if (typeof msg === 'string') {
    if (!enc) {
      // Inspired by stringToUtf8ByteArray() in closure-library by Google
      // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143
      // Apache License 2.0
      // https://github.com/google/closure-library/blob/master/LICENSE
      var p = 0;

      for (var i = 0; i < msg.length; i++) {
        var c = msg.charCodeAt(i);

        if (c < 128) {
          res[p++] = c;
        } else if (c < 2048) {
          res[p++] = c >> 6 | 192;
          res[p++] = c & 63 | 128;
        } else if (isSurrogatePair(msg, i)) {
          c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);
          res[p++] = c >> 18 | 240;
          res[p++] = c >> 12 & 63 | 128;
          res[p++] = c >> 6 & 63 | 128;
          res[p++] = c & 63 | 128;
        } else {
          res[p++] = c >> 12 | 224;
          res[p++] = c >> 6 & 63 | 128;
          res[p++] = c & 63 | 128;
        }
      }
    } else if (enc === 'hex') {
      msg = msg.replace(/[^a-z0-9]+/ig, '');
      if (msg.length % 2 !== 0) msg = '0' + msg;

      for (i = 0; i < msg.length; i += 2) {
        res.push(parseInt(msg[i] + msg[i + 1], 16));
      }
    }
  } else {
    for (i = 0; i < msg.length; i++) {
      res[i] = msg[i] | 0;
    }
  }

  return res;
}

exports.toArray = toArray;

function toHex(msg) {
  var res = '';

  for (var i = 0; i < msg.length; i++) {
    res += zero2(msg[i].toString(16));
  }

  return res;
}

exports.toHex = toHex;

function htonl(w) {
  var res = w >>> 24 | w >>> 8 & 0xff00 | w << 8 & 0xff0000 | (w & 0xff) << 24;
  return res >>> 0;
}

exports.htonl = htonl;

function toHex32(msg, endian) {
  var res = '';

  for (var i = 0; i < msg.length; i++) {
    var w = msg[i];
    if (endian === 'little') w = htonl(w);
    res += zero8(w.toString(16));
  }

  return res;
}

exports.toHex32 = toHex32;

function zero2(word) {
  if (word.length === 1) return '0' + word;else return word;
}

exports.zero2 = zero2;

function zero8(word) {
  if (word.length === 7) return '0' + word;else if (word.length === 6) return '00' + word;else if (word.length === 5) return '000' + word;else if (word.length === 4) return '0000' + word;else if (word.length === 3) return '00000' + word;else if (word.length === 2) return '000000' + word;else if (word.length === 1) return '0000000' + word;else return word;
}

exports.zero8 = zero8;

function join32(msg, start, end, endian) {
  var len = end - start;
  assert(len % 4 === 0);
  var res = new Array(len / 4);

  for (var i = 0, k = start; i < res.length; i++, k += 4) {
    var w;
    if (endian === 'big') w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];else w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
    res[i] = w >>> 0;
  }

  return res;
}

exports.join32 = join32;

function split32(msg, endian) {
  var res = new Array(msg.length * 4);

  for (var i = 0, k = 0; i < msg.length; i++, k += 4) {
    var m = msg[i];

    if (endian === 'big') {
      res[k] = m >>> 24;
      res[k + 1] = m >>> 16 & 0xff;
      res[k + 2] = m >>> 8 & 0xff;
      res[k + 3] = m & 0xff;
    } else {
      res[k + 3] = m >>> 24;
      res[k + 2] = m >>> 16 & 0xff;
      res[k + 1] = m >>> 8 & 0xff;
      res[k] = m & 0xff;
    }
  }

  return res;
}

exports.split32 = split32;

function rotr32(w, b) {
  return w >>> b | w << 32 - b;
}

exports.rotr32 = rotr32;

function rotl32(w, b) {
  return w << b | w >>> 32 - b;
}

exports.rotl32 = rotl32;

function sum32(a, b) {
  return a + b >>> 0;
}

exports.sum32 = sum32;

function sum32_3(a, b, c) {
  return a + b + c >>> 0;
}

exports.sum32_3 = sum32_3;

function sum32_4(a, b, c, d) {
  return a + b + c + d >>> 0;
}

exports.sum32_4 = sum32_4;

function sum32_5(a, b, c, d, e) {
  return a + b + c + d + e >>> 0;
}

exports.sum32_5 = sum32_5;

function sum64(buf, pos, ah, al) {
  var bh = buf[pos];
  var bl = buf[pos + 1];
  var lo = al + bl >>> 0;
  var hi = (lo < al ? 1 : 0) + ah + bh;
  buf[pos] = hi >>> 0;
  buf[pos + 1] = lo;
}

exports.sum64 = sum64;

function sum64_hi(ah, al, bh, bl) {
  var lo = al + bl >>> 0;
  var hi = (lo < al ? 1 : 0) + ah + bh;
  return hi >>> 0;
}

exports.sum64_hi = sum64_hi;

function sum64_lo(ah, al, bh, bl) {
  var lo = al + bl;
  return lo >>> 0;
}

exports.sum64_lo = sum64_lo;

function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
  var carry = 0;
  var lo = al;
  lo = lo + bl >>> 0;
  carry += lo < al ? 1 : 0;
  lo = lo + cl >>> 0;
  carry += lo < cl ? 1 : 0;
  lo = lo + dl >>> 0;
  carry += lo < dl ? 1 : 0;
  var hi = ah + bh + ch + dh + carry;
  return hi >>> 0;
}

exports.sum64_4_hi = sum64_4_hi;

function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
  var lo = al + bl + cl + dl;
  return lo >>> 0;
}

exports.sum64_4_lo = sum64_4_lo;

function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
  var carry = 0;
  var lo = al;
  lo = lo + bl >>> 0;
  carry += lo < al ? 1 : 0;
  lo = lo + cl >>> 0;
  carry += lo < cl ? 1 : 0;
  lo = lo + dl >>> 0;
  carry += lo < dl ? 1 : 0;
  lo = lo + el >>> 0;
  carry += lo < el ? 1 : 0;
  var hi = ah + bh + ch + dh + eh + carry;
  return hi >>> 0;
}

exports.sum64_5_hi = sum64_5_hi;

function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
  var lo = al + bl + cl + dl + el;
  return lo >>> 0;
}

exports.sum64_5_lo = sum64_5_lo;

function rotr64_hi(ah, al, num) {
  var r = al << 32 - num | ah >>> num;
  return r >>> 0;
}

exports.rotr64_hi = rotr64_hi;

function rotr64_lo(ah, al, num) {
  var r = ah << 32 - num | al >>> num;
  return r >>> 0;
}

exports.rotr64_lo = rotr64_lo;

function shr64_hi(ah, al, num) {
  return ah >>> num;
}

exports.shr64_hi = shr64_hi;

function shr64_lo(ah, al, num) {
  var r = ah << 32 - num | al >>> num;
  return r >>> 0;
}

exports.shr64_lo = shr64_lo;

/***/ }),

/***/ "./node_modules/hmac-drbg/lib/hmac-drbg.js":
/*!*************************************************!*\
  !*** ./node_modules/hmac-drbg/lib/hmac-drbg.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var hash = __webpack_require__(/*! hash.js */ "./node_modules/hash.js/lib/hash.js");

var utils = __webpack_require__(/*! minimalistic-crypto-utils */ "./node_modules/minimalistic-crypto-utils/lib/utils.js");

var assert = __webpack_require__(/*! minimalistic-assert */ "./node_modules/minimalistic-assert/index.js");

function HmacDRBG(options) {
  if (!(this instanceof HmacDRBG)) return new HmacDRBG(options);
  this.hash = options.hash;
  this.predResist = !!options.predResist;
  this.outLen = this.hash.outSize;
  this.minEntropy = options.minEntropy || this.hash.hmacStrength;
  this._reseed = null;
  this.reseedInterval = null;
  this.K = null;
  this.V = null;
  var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');
  var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');
  var pers = utils.toArray(options.pers, options.persEnc || 'hex');
  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');

  this._init(entropy, nonce, pers);
}

module.exports = HmacDRBG;

HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
  var seed = entropy.concat(nonce).concat(pers);
  this.K = new Array(this.outLen / 8);
  this.V = new Array(this.outLen / 8);

  for (var i = 0; i < this.V.length; i++) {
    this.K[i] = 0x00;
    this.V[i] = 0x01;
  }

  this._update(seed);

  this._reseed = 1;
  this.reseedInterval = 0x1000000000000; // 2^48
};

HmacDRBG.prototype._hmac = function hmac() {
  return new hash.hmac(this.hash, this.K);
};

HmacDRBG.prototype._update = function update(seed) {
  var kmac = this._hmac().update(this.V).update([0x00]);

  if (seed) kmac = kmac.update(seed);
  this.K = kmac.digest();
  this.V = this._hmac().update(this.V).digest();
  if (!seed) return;
  this.K = this._hmac().update(this.V).update([0x01]).update(seed).digest();
  this.V = this._hmac().update(this.V).digest();
};

HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
  // Optional entropy enc
  if (typeof entropyEnc !== 'string') {
    addEnc = add;
    add = entropyEnc;
    entropyEnc = null;
  }

  entropy = utils.toArray(entropy, entropyEnc);
  add = utils.toArray(add, addEnc);
  assert(entropy.length >= this.minEntropy / 8, 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');

  this._update(entropy.concat(add || []));

  this._reseed = 1;
};

HmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {
  if (this._reseed > this.reseedInterval) throw new Error('Reseed is required'); // Optional encoding

  if (typeof enc !== 'string') {
    addEnc = add;
    add = enc;
    enc = null;
  } // Optional additional data


  if (add) {
    add = utils.toArray(add, addEnc || 'hex');

    this._update(add);
  }

  var temp = [];

  while (temp.length < len) {
    this.V = this._hmac().update(this.V).digest();
    temp = temp.concat(this.V);
  }

  var res = temp.slice(0, len);

  this._update(add);

  this._reseed++;
  return utils.encode(res, enc);
};

/***/ }),

/***/ "./node_modules/inherits/inherits_browser.js":
/*!***************************************************!*\
  !*** ./node_modules/inherits/inherits_browser.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(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() {};

    TempCtor.prototype = superCtor.prototype;
    ctor.prototype = new TempCtor();
    ctor.prototype.constructor = ctor;
  };
}

/***/ }),

/***/ "./node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js":
/*!****************************************************************************!*\
  !*** ./node_modules/libsodium-wrappers/dist/modules/libsodium-wrappers.js ***!
  \****************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

!function (e) {
  function t(e, t) {
    "use strict";

    var r,
        a = "uint8array",
        _ = t.ready.then(function () {
      function a() {
        if (0 !== r._sodium_init()) throw new Error("libsodium was not correctly initialized.");

        for (var t = ["crypto_aead_chacha20poly1305_decrypt", "crypto_aead_chacha20poly1305_decrypt_detached", "crypto_aead_chacha20poly1305_encrypt", "crypto_aead_chacha20poly1305_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_decrypt", "crypto_aead_chacha20poly1305_ietf_decrypt_detached", "crypto_aead_chacha20poly1305_ietf_encrypt", "crypto_aead_chacha20poly1305_ietf_encrypt_detached", "crypto_aead_chacha20poly1305_ietf_keygen", "crypto_aead_chacha20poly1305_keygen", "crypto_aead_xchacha20poly1305_ietf_decrypt", "crypto_aead_xchacha20poly1305_ietf_decrypt_detached", "crypto_aead_xchacha20poly1305_ietf_encrypt", "crypto_aead_xchacha20poly1305_ietf_encrypt_detached", "crypto_aead_xchacha20poly1305_ietf_keygen", "crypto_auth", "crypto_auth_hmacsha256", "crypto_auth_hmacsha256_keygen", "crypto_auth_hmacsha256_verify", "crypto_auth_hmacsha512", "crypto_auth_hmacsha512_keygen", "crypto_auth_hmacsha512_verify", "crypto_auth_keygen", "crypto_auth_verify", "crypto_box_beforenm", "crypto_box_curve25519xchacha20poly1305_keypair", "crypto_box_curve25519xchacha20poly1305_seal", "crypto_box_curve25519xchacha20poly1305_seal_open", "crypto_box_detached", "crypto_box_easy", "crypto_box_easy_afternm", "crypto_box_keypair", "crypto_box_open_detached", "crypto_box_open_easy", "crypto_box_open_easy_afternm", "crypto_box_seal", "crypto_box_seal_open", "crypto_box_seed_keypair", "crypto_core_ristretto255_add", "crypto_core_ristretto255_from_hash", "crypto_core_ristretto255_is_valid_point", "crypto_core_ristretto255_random", "crypto_core_ristretto255_scalar_add", "crypto_core_ristretto255_scalar_complement", "crypto_core_ristretto255_scalar_invert", "crypto_core_ristretto255_scalar_mul", "crypto_core_ristretto255_scalar_negate", "crypto_core_ristretto255_scalar_random", "crypto_core_ristretto255_scalar_reduce", "crypto_core_ristretto255_scalar_sub", "crypto_core_ristretto255_sub", "crypto_generichash", "crypto_generichash_blake2b_salt_personal", "crypto_generichash_final", "crypto_generichash_init", "crypto_generichash_keygen", "crypto_generichash_update", "crypto_hash", "crypto_hash_sha256", "crypto_hash_sha512", "crypto_kdf_derive_from_key", "crypto_kdf_keygen", "crypto_kx_client_session_keys", "crypto_kx_keypair", "crypto_kx_seed_keypair", "crypto_kx_server_session_keys", "crypto_onetimeauth", "crypto_onetimeauth_final", "crypto_onetimeauth_init", "crypto_onetimeauth_keygen", "crypto_onetimeauth_update", "crypto_onetimeauth_verify", "crypto_pwhash", "crypto_pwhash_scryptsalsa208sha256", "crypto_pwhash_scryptsalsa208sha256_ll", "crypto_pwhash_scryptsalsa208sha256_str", "crypto_pwhash_scryptsalsa208sha256_str_verify", "crypto_pwhash_str", "crypto_pwhash_str_verify", "crypto_scalarmult", "crypto_scalarmult_base", "crypto_scalarmult_ristretto255", "crypto_scalarmult_ristretto255_base", "crypto_secretbox_detached", "crypto_secretbox_easy", "crypto_secretbox_keygen", "crypto_secretbox_open_detached", "crypto_secretbox_open_easy", "crypto_secretstream_xchacha20poly1305_init_pull", "crypto_secretstream_xchacha20poly1305_init_push", "crypto_secretstream_xchacha20poly1305_keygen", "crypto_secretstream_xchacha20poly1305_pull", "crypto_secretstream_xchacha20poly1305_push", "crypto_secretstream_xchacha20poly1305_rekey", "crypto_shorthash", "crypto_shorthash_keygen", "crypto_shorthash_siphashx24", "crypto_sign", "crypto_sign_detached", "crypto_sign_ed25519_pk_to_curve25519", "crypto_sign_ed25519_sk_to_curve25519", "crypto_sign_ed25519_sk_to_pk", "crypto_sign_ed25519_sk_to_seed", "crypto_sign_final_create", "crypto_sign_final_verify", "crypto_sign_init", "crypto_sign_keypair", "crypto_sign_open", "crypto_sign_seed_keypair", "crypto_sign_update", "crypto_sign_verify_detached", "crypto_stream_chacha20", "crypto_stream_chacha20_ietf_xor", "crypto_stream_chacha20_ietf_xor_ic", "crypto_stream_chacha20_keygen", "crypto_stream_chacha20_xor", "crypto_stream_chacha20_xor_ic", "crypto_stream_keygen", "crypto_stream_xchacha20_keygen", "crypto_stream_xchacha20_xor", "crypto_stream_xchacha20_xor_ic", "randombytes_buf", "randombytes_buf_deterministic", "randombytes_close", "randombytes_random", "randombytes_set_implementation", "randombytes_stir", "randombytes_uniform", "sodium_version_string"], a = [x, E, w, S, T, Y, A, B, K, I, M, L, N, U, O, R, P, C, G, D, X, V, F, H, z, j, q, W, J, Q, Z, $, ee, te, re, ae, _e, ne, se, ce, he, oe, pe, ye, ie, le, ue, ve, de, ge, be, fe, me, ke, xe, Ee, we, Se, Te, Ye, Ae, Be, Ke, Ie, Me, Le, Ne, Ue, Oe, Re, Pe, Ce, Ge, De, Xe, Ve, Fe, He, ze, je, qe, We, Je, Qe, Ze, $e, et, tt, rt, at, _t, nt, st, ct, ht, ot, pt, yt, it, lt, ut, vt, dt, gt, bt, ft, mt, kt, xt, Et, wt, St, Tt, Yt, At, Bt, Kt, It, Mt, Lt, Nt, Ut, Ot, Rt, Pt, Ct, Gt, Dt, Xt], _ = 0; _ < a.length; _++) {
          "function" == typeof r["_" + t[_]] && (e[t[_]] = a[_]);
        }

        var n = ["SODIUM_LIBRARY_VERSION_MAJOR", "SODIUM_LIBRARY_VERSION_MINOR", "crypto_aead_chacha20poly1305_ABYTES", "crypto_aead_chacha20poly1305_KEYBYTES", "crypto_aead_chacha20poly1305_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_NPUBBYTES", "crypto_aead_chacha20poly1305_NSECBYTES", "crypto_aead_chacha20poly1305_ietf_ABYTES", "crypto_aead_chacha20poly1305_ietf_KEYBYTES", "crypto_aead_chacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_chacha20poly1305_ietf_NPUBBYTES", "crypto_aead_chacha20poly1305_ietf_NSECBYTES", "crypto_aead_xchacha20poly1305_ietf_ABYTES", "crypto_aead_xchacha20poly1305_ietf_KEYBYTES", "crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX", "crypto_aead_xchacha20poly1305_ietf_NPUBBYTES", "crypto_aead_xchacha20poly1305_ietf_NSECBYTES", "crypto_auth_BYTES", "crypto_auth_KEYBYTES", "crypto_auth_hmacsha256_BYTES", "crypto_auth_hmacsha256_KEYBYTES", "crypto_auth_hmacsha512_BYTES", "crypto_auth_hmacsha512_KEYBYTES", "crypto_box_BEFORENMBYTES", "crypto_box_MACBYTES", "crypto_box_MESSAGEBYTES_MAX", "crypto_box_NONCEBYTES", "crypto_box_PUBLICKEYBYTES", "crypto_box_SEALBYTES", "crypto_box_SECRETKEYBYTES", "crypto_box_SEEDBYTES", "crypto_box_curve25519xchacha20poly1305_NONCEBYTES", "crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES", "crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES", "crypto_core_hchacha20_CONSTBYTES", "crypto_core_hchacha20_INPUTBYTES", "crypto_core_hchacha20_KEYBYTES", "crypto_core_hchacha20_OUTPUTBYTES", "crypto_core_ristretto255_BYTES", "crypto_core_ristretto255_HASHBYTES", "crypto_core_ristretto255_NONREDUCEDSCALARBYTES", "crypto_core_ristretto255_SCALARBYTES", "crypto_generichash_BYTES", "crypto_generichash_BYTES_MAX", "crypto_generichash_BYTES_MIN", "crypto_generichash_KEYBYTES", "crypto_generichash_KEYBYTES_MAX", "crypto_generichash_KEYBYTES_MIN", "crypto_generichash_blake2b_BYTES", "crypto_generichash_blake2b_BYTES_MAX", "crypto_generichash_blake2b_BYTES_MIN", "crypto_generichash_blake2b_KEYBYTES", "crypto_generichash_blake2b_KEYBYTES_MAX", "crypto_generichash_blake2b_KEYBYTES_MIN", "crypto_generichash_blake2b_PERSONALBYTES", "crypto_generichash_blake2b_SALTBYTES", "crypto_hash_BYTES", "crypto_hash_sha256_BYTES", "crypto_hash_sha512_BYTES", "crypto_kdf_BYTES_MAX", "crypto_kdf_BYTES_MIN", "crypto_kdf_CONTEXTBYTES", "crypto_kdf_KEYBYTES", "crypto_kx_PUBLICKEYBYTES", "crypto_kx_SECRETKEYBYTES", "crypto_kx_SEEDBYTES", "crypto_kx_SESSIONKEYBYTES", "crypto_onetimeauth_BYTES", "crypto_onetimeauth_KEYBYTES", "crypto_pwhash_ALG_ARGON2I13", "crypto_pwhash_ALG_ARGON2ID13", "crypto_pwhash_ALG_DEFAULT", "crypto_pwhash_BYTES_MAX", "crypto_pwhash_BYTES_MIN", "crypto_pwhash_MEMLIMIT_INTERACTIVE", "crypto_pwhash_MEMLIMIT_MAX", "crypto_pwhash_MEMLIMIT_MIN", "crypto_pwhash_MEMLIMIT_MODERATE", "crypto_pwhash_MEMLIMIT_SENSITIVE", "crypto_pwhash_OPSLIMIT_INTERACTIVE", "crypto_pwhash_OPSLIMIT_MAX", "crypto_pwhash_OPSLIMIT_MIN", "crypto_pwhash_OPSLIMIT_MODERATE", "crypto_pwhash_OPSLIMIT_SENSITIVE", "crypto_pwhash_PASSWD_MAX", "crypto_pwhash_PASSWD_MIN", "crypto_pwhash_SALTBYTES", "crypto_pwhash_STRBYTES", "crypto_pwhash_STR_VERIFY", "crypto_pwhash_scryptsalsa208sha256_BYTES_MAX", "crypto_pwhash_scryptsalsa208sha256_BYTES_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN", "crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_SENSITIVE", "crypto_pwhash_scryptsalsa208sha256_SALTBYTES", "crypto_pwhash_scryptsalsa208sha256_STRBYTES", "crypto_pwhash_scryptsalsa208sha256_STR_VERIFY", "crypto_scalarmult_BYTES", "crypto_scalarmult_SCALARBYTES", "crypto_scalarmult_ristretto255_BYTES", "crypto_scalarmult_ristretto255_SCALARBYTES", "crypto_secretbox_KEYBYTES", "crypto_secretbox_MACBYTES", "crypto_secretbox_MESSAGEBYTES_MAX", "crypto_secretbox_NONCEBYTES", "crypto_secretstream_xchacha20poly1305_ABYTES", "crypto_secretstream_xchacha20poly1305_HEADERBYTES", "crypto_secretstream_xchacha20poly1305_KEYBYTES", "crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX", "crypto_secretstream_xchacha20poly1305_MESSAGESBYTES_MAX", "crypto_secretstream_xchacha20poly1305_NPUBBYTES", "crypto_secretstream_xchacha20poly1305_TAG_FINAL", "crypto_secretstream_xchacha20poly1305_TAG_MESSAGE", "crypto_secretstream_xchacha20poly1305_TAG_PUSH", "crypto_secretstream_xchacha20poly1305_TAG_REKEY", "crypto_shorthash_BYTES", "crypto_shorthash_KEYBYTES", "crypto_shorthash_siphashx24_BYTES", "crypto_shorthash_siphashx24_KEYBYTES", "crypto_sign_BYTES", "crypto_sign_MESSAGEBYTES_MAX", "crypto_sign_PUBLICKEYBYTES", "crypto_sign_SECRETKEYBYTES", "crypto_sign_SEEDBYTES", "crypto_stream_KEYBYTES", "crypto_stream_MESSAGEBYTES_MAX", "crypto_stream_NONCEBYTES", "crypto_stream_chacha20_KEYBYTES", "crypto_stream_chacha20_NONCEBYTES", "crypto_stream_chacha20_ietf_KEYBYTES", "crypto_stream_chacha20_ietf_MESSAGEBYTES_MAX", "crypto_stream_chacha20_ietf_NONCEBYTES", "crypto_stream_xchacha20_KEYBYTES", "crypto_stream_xchacha20_MESSAGEBYTES_MAX", "crypto_stream_xchacha20_NONCEBYTES", "randombytes_SEEDBYTES"];

        for (_ = 0; _ < n.length; _++) {
          "function" == typeof (c = r["_" + n[_].toLowerCase()]) && (e[n[_]] = c());
        }

        var s = ["SODIUM_VERSION_STRING", "crypto_pwhash_STRPREFIX", "crypto_pwhash_scryptsalsa208sha256_STRPREFIX"];

        for (_ = 0; _ < s.length; _++) {
          var c;
          "function" == typeof (c = r["_" + s[_].toLowerCase()]) && (e[s[_]] = r.UTF8ToString(c()));
        }
      }

      r = t;

      try {
        a();

        var _ = new Uint8Array([98, 97, 108, 108, 115]),
            n = e.randombytes_buf(e.crypto_secretbox_NONCEBYTES),
            s = e.randombytes_buf(e.crypto_secretbox_KEYBYTES),
            c = e.crypto_secretbox_easy(_, n, s),
            h = e.crypto_secretbox_open_easy(c, n, s);

        if (e.memcmp(_, h)) return;
      } catch (e) {
        if (null == r.useBackupModule) throw new Error("Both wasm and asm failed to load" + e);
      }

      r.useBackupModule(), a();
    });

    function n(e) {
      if ("function" == typeof TextEncoder) return new TextEncoder().encode(e);
      e = unescape(encodeURIComponent(e));

      for (var t = new Uint8Array(e.length), r = 0, a = e.length; r < a; r++) {
        t[r] = e.charCodeAt(r);
      }

      return t;
    }

    function s(e) {
      if ("function" == typeof TextDecoder) return new TextDecoder("utf-8", {
        fatal: !0
      }).decode(e);
      var t = Math.ceil(e.length / 8192);
      if (t <= 1) try {
        return decodeURIComponent(escape(String.fromCharCode.apply(null, e)));
      } catch (e) {
        throw new TypeError("The encoded data was not valid.");
      }

      for (var r = "", a = 0, _ = 0; _ < t; _++) {
        var n = Array.prototype.slice.call(e, 8192 * _ + a, 8192 * (_ + 1) + a);

        if (0 != n.length) {
          var c,
              h = n.length,
              o = 0;

          do {
            var p = n[--h];
            p >= 240 ? (o = 4, c = !0) : p >= 224 ? (o = 3, c = !0) : p >= 192 ? (o = 2, c = !0) : p < 128 && (o = 1, c = !0);
          } while (!c);

          for (var y = o - (n.length - h), i = 0; i < y; i++) {
            a--, n.pop();
          }

          r += s(n);
        }
      }

      return r;
    }

    function c(e) {
      e = k(null, e, "input");

      for (var t, r, a, _ = "", n = 0; n < e.length; n++) {
        a = 87 + (r = 15 & e[n]) + (r - 10 >> 8 & -39) << 8 | 87 + (t = e[n] >>> 4) + (t - 10 >> 8 & -39), _ += String.fromCharCode(255 & a) + String.fromCharCode(a >>> 8);
      }

      return _;
    }

    var h = {
      ORIGINAL: 1,
      ORIGINAL_NO_PADDING: 3,
      URLSAFE: 5,
      URLSAFE_NO_PADDING: 7
    };

    function o(e) {
      if (null == e) return h.URLSAFE_NO_PADDING;
      if (e !== h.ORIGINAL && e !== h.ORIGINAL_NO_PADDING && e !== h.URLSAFE && e != h.URLSAFE_NO_PADDING) throw new Error("unsupported base64 variant");
      return e;
    }

    function p(e, t) {
      t = o(t), e = k(_, e, "input");
      var a,
          _ = [],
          n = 0 | Math.floor(e.length / 3),
          c = e.length - 3 * n,
          h = 4 * n + (0 !== c ? 0 == (2 & t) ? 4 : 2 + (c >>> 1) : 0),
          p = new u(h + 1),
          y = v(e);
      return _.push(y), _.push(p.address), 0 === r._sodium_bin2base64(p.address, p.length, y, e.length, t) && b(_, "conversion failed"), p.length = h, a = s(p.to_Uint8Array()), g(_), a;
    }

    function y(e, t) {
      var r = t || a;
      if (!i(r)) throw new Error(r + " output format is not available");

      if (e instanceof u) {
        if ("uint8array" === r) return e.to_Uint8Array();
        if ("text" === r) return s(e.to_Uint8Array());
        if ("hex" === r) return c(e.to_Uint8Array());
        if ("base64" === r) return p(e.to_Uint8Array(), h.URLSAFE_NO_PADDING);
        throw new Error('What is output format "' + r + '"?');
      }

      if ("object" == _typeof(e)) {
        for (var _ = Object.keys(e), n = {}, o = 0; o < _.length; o++) {
          n[_[o]] = y(e[_[o]], r);
        }

        return n;
      }

      if ("string" == typeof e) return e;
      throw new TypeError("Cannot format output");
    }

    function i(e) {
      for (var t = ["uint8array", "text", "hex", "base64"], r = 0; r < t.length; r++) {
        if (t[r] === e) return !0;
      }

      return !1;
    }

    function l(e) {
      if (e) {
        if ("string" != typeof e) throw new TypeError("When defined, the output format must be a string");
        if (!i(e)) throw new Error(e + " is not a supported output format");
      }
    }

    function u(e) {
      this.length = e, this.address = d(e);
    }

    function v(e) {
      var t = d(e.length);
      return r.HEAPU8.set(e, t), t;
    }

    function d(e) {
      var t = r._malloc(e);

      if (0 === t) throw {
        message: "_malloc() failed",
        length: e
      };
      return t;
    }

    function g(e) {
      if (e) for (var t = 0; t < e.length; t++) {
        a = e[t], r._free(a);
      }
      var a;
    }

    function b(e, t) {
      throw g(e), new Error(t);
    }

    function f(e, t) {
      throw g(e), new TypeError(t);
    }

    function m(e, t, r) {
      null == t && f(e, r + " cannot be null or undefined");
    }

    function k(e, t, r) {
      return m(e, t, r), t instanceof Uint8Array ? t : "string" == typeof t ? n(t) : void f(e, "unsupported input type for " + r);
    }

    function x(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = null;
      null != e && (h = v(e = k(c, e, "secret_nonce")), e.length, c.push(h)), t = k(c, t, "ciphertext");

      var o,
          p = r._crypto_aead_chacha20poly1305_abytes(),
          i = t.length;

      i < p && f(c, "ciphertext is too short"), o = v(t), c.push(o);
      var d = null,
          m = 0;
      null != a && (d = v(a = k(c, a, "additional_data")), m = a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var x,
          E = 0 | r._crypto_aead_chacha20poly1305_npubbytes();

      _.length !== E && f(c, "invalid public_nonce length"), x = v(_), c.push(x), n = k(c, n, "key");

      var w,
          S = 0 | r._crypto_aead_chacha20poly1305_keybytes();

      n.length !== S && f(c, "invalid key length"), w = v(n), c.push(w);
      var T = new u(i - r._crypto_aead_chacha20poly1305_abytes() | 0),
          Y = T.address;

      if (c.push(Y), 0 === r._crypto_aead_chacha20poly1305_decrypt(Y, null, h, o, i, 0, d, m, 0, x, w)) {
        var A = y(T, s);
        return g(c), A;
      }

      b(c, "ciphertext cannot be decrypted using that key");
    }

    function E(e, t, a, _, n, s, c) {
      var h = [];
      l(c);
      var o = null;
      null != e && (o = v(e = k(h, e, "secret_nonce")), e.length, h.push(o));
      var p = v(t = k(h, t, "ciphertext")),
          i = t.length;
      h.push(p), a = k(h, a, "mac");

      var d,
          m = 0 | r._crypto_box_macbytes();

      a.length !== m && f(h, "invalid mac length"), d = v(a), h.push(d);
      var x = null,
          E = 0;
      null != _ && (x = v(_ = k(h, _, "additional_data")), E = _.length, h.push(x)), n = k(h, n, "public_nonce");

      var w,
          S = 0 | r._crypto_aead_chacha20poly1305_npubbytes();

      n.length !== S && f(h, "invalid public_nonce length"), w = v(n), h.push(w), s = k(h, s, "key");

      var T,
          Y = 0 | r._crypto_aead_chacha20poly1305_keybytes();

      s.length !== Y && f(h, "invalid key length"), T = v(s), h.push(T);
      var A = new u(0 | i),
          B = A.address;

      if (h.push(B), 0 === r._crypto_aead_chacha20poly1305_decrypt_detached(B, o, p, i, 0, d, x, E, 0, w, T)) {
        var K = y(A, c);
        return g(h), K;
      }

      b(h, "ciphertext cannot be decrypted using that key");
    }

    function w(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_chacha20poly1305_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_chacha20poly1305_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(o + r._crypto_aead_chacha20poly1305_abytes() | 0),
          T = S.address;

      if (c.push(T), 0 === r._crypto_aead_chacha20poly1305_encrypt(T, null, h, o, 0, p, i, 0, d, m, E)) {
        var Y = y(S, s);
        return g(c), Y;
      }

      b(c, "invalid usage");
    }

    function S(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_chacha20poly1305_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_chacha20poly1305_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(0 | o),
          T = S.address;
      c.push(T);
      var Y = new u(0 | r._crypto_aead_chacha20poly1305_abytes()),
          A = Y.address;

      if (c.push(A), 0 === r._crypto_aead_chacha20poly1305_encrypt_detached(T, A, null, h, o, 0, p, i, 0, d, m, E)) {
        var B = y({
          ciphertext: S,
          mac: Y
        }, s);
        return g(c), B;
      }

      b(c, "invalid usage");
    }

    function T(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = null;
      null != e && (h = v(e = k(c, e, "secret_nonce")), e.length, c.push(h)), t = k(c, t, "ciphertext");

      var o,
          p = r._crypto_aead_chacha20poly1305_ietf_abytes(),
          i = t.length;

      i < p && f(c, "ciphertext is too short"), o = v(t), c.push(o);
      var d = null,
          m = 0;
      null != a && (d = v(a = k(c, a, "additional_data")), m = a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var x,
          E = 0 | r._crypto_aead_chacha20poly1305_ietf_npubbytes();

      _.length !== E && f(c, "invalid public_nonce length"), x = v(_), c.push(x), n = k(c, n, "key");

      var w,
          S = 0 | r._crypto_aead_chacha20poly1305_ietf_keybytes();

      n.length !== S && f(c, "invalid key length"), w = v(n), c.push(w);
      var T = new u(i - r._crypto_aead_chacha20poly1305_ietf_abytes() | 0),
          Y = T.address;

      if (c.push(Y), 0 === r._crypto_aead_chacha20poly1305_ietf_decrypt(Y, null, h, o, i, 0, d, m, 0, x, w)) {
        var A = y(T, s);
        return g(c), A;
      }

      b(c, "ciphertext cannot be decrypted using that key");
    }

    function Y(e, t, a, _, n, s, c) {
      var h = [];
      l(c);
      var o = null;
      null != e && (o = v(e = k(h, e, "secret_nonce")), e.length, h.push(o));
      var p = v(t = k(h, t, "ciphertext")),
          i = t.length;
      h.push(p), a = k(h, a, "mac");

      var d,
          m = 0 | r._crypto_box_macbytes();

      a.length !== m && f(h, "invalid mac length"), d = v(a), h.push(d);
      var x = null,
          E = 0;
      null != _ && (x = v(_ = k(h, _, "additional_data")), E = _.length, h.push(x)), n = k(h, n, "public_nonce");

      var w,
          S = 0 | r._crypto_aead_chacha20poly1305_ietf_npubbytes();

      n.length !== S && f(h, "invalid public_nonce length"), w = v(n), h.push(w), s = k(h, s, "key");

      var T,
          Y = 0 | r._crypto_aead_chacha20poly1305_ietf_keybytes();

      s.length !== Y && f(h, "invalid key length"), T = v(s), h.push(T);
      var A = new u(0 | i),
          B = A.address;

      if (h.push(B), 0 === r._crypto_aead_chacha20poly1305_ietf_decrypt_detached(B, o, p, i, 0, d, x, E, 0, w, T)) {
        var K = y(A, c);
        return g(h), K;
      }

      b(h, "ciphertext cannot be decrypted using that key");
    }

    function A(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_chacha20poly1305_ietf_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_chacha20poly1305_ietf_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(o + r._crypto_aead_chacha20poly1305_ietf_abytes() | 0),
          T = S.address;

      if (c.push(T), 0 === r._crypto_aead_chacha20poly1305_ietf_encrypt(T, null, h, o, 0, p, i, 0, d, m, E)) {
        var Y = y(S, s);
        return g(c), Y;
      }

      b(c, "invalid usage");
    }

    function B(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_chacha20poly1305_ietf_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_chacha20poly1305_ietf_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(0 | o),
          T = S.address;
      c.push(T);
      var Y = new u(0 | r._crypto_aead_chacha20poly1305_ietf_abytes()),
          A = Y.address;

      if (c.push(A), 0 === r._crypto_aead_chacha20poly1305_ietf_encrypt_detached(T, A, null, h, o, 0, p, i, 0, d, m, E)) {
        var B = y({
          ciphertext: S,
          mac: Y
        }, s);
        return g(c), B;
      }

      b(c, "invalid usage");
    }

    function K(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_aead_chacha20poly1305_ietf_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_aead_chacha20poly1305_ietf_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function I(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_aead_chacha20poly1305_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_aead_chacha20poly1305_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function M(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = null;
      null != e && (h = v(e = k(c, e, "secret_nonce")), e.length, c.push(h)), t = k(c, t, "ciphertext");

      var o,
          p = r._crypto_aead_xchacha20poly1305_ietf_abytes(),
          i = t.length;

      i < p && f(c, "ciphertext is too short"), o = v(t), c.push(o);
      var d = null,
          m = 0;
      null != a && (d = v(a = k(c, a, "additional_data")), m = a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var x,
          E = 0 | r._crypto_aead_xchacha20poly1305_ietf_npubbytes();

      _.length !== E && f(c, "invalid public_nonce length"), x = v(_), c.push(x), n = k(c, n, "key");

      var w,
          S = 0 | r._crypto_aead_xchacha20poly1305_ietf_keybytes();

      n.length !== S && f(c, "invalid key length"), w = v(n), c.push(w);
      var T = new u(i - r._crypto_aead_xchacha20poly1305_ietf_abytes() | 0),
          Y = T.address;

      if (c.push(Y), 0 === r._crypto_aead_xchacha20poly1305_ietf_decrypt(Y, null, h, o, i, 0, d, m, 0, x, w)) {
        var A = y(T, s);
        return g(c), A;
      }

      b(c, "ciphertext cannot be decrypted using that key");
    }

    function L(e, t, a, _, n, s, c) {
      var h = [];
      l(c);
      var o = null;
      null != e && (o = v(e = k(h, e, "secret_nonce")), e.length, h.push(o));
      var p = v(t = k(h, t, "ciphertext")),
          i = t.length;
      h.push(p), a = k(h, a, "mac");

      var d,
          m = 0 | r._crypto_box_macbytes();

      a.length !== m && f(h, "invalid mac length"), d = v(a), h.push(d);
      var x = null,
          E = 0;
      null != _ && (x = v(_ = k(h, _, "additional_data")), E = _.length, h.push(x)), n = k(h, n, "public_nonce");

      var w,
          S = 0 | r._crypto_aead_xchacha20poly1305_ietf_npubbytes();

      n.length !== S && f(h, "invalid public_nonce length"), w = v(n), h.push(w), s = k(h, s, "key");

      var T,
          Y = 0 | r._crypto_aead_xchacha20poly1305_ietf_keybytes();

      s.length !== Y && f(h, "invalid key length"), T = v(s), h.push(T);
      var A = new u(0 | i),
          B = A.address;

      if (h.push(B), 0 === r._crypto_aead_xchacha20poly1305_ietf_decrypt_detached(B, o, p, i, 0, d, x, E, 0, w, T)) {
        var K = y(A, c);
        return g(h), K;
      }

      b(h, "ciphertext cannot be decrypted using that key");
    }

    function N(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_xchacha20poly1305_ietf_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_xchacha20poly1305_ietf_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(o + r._crypto_aead_xchacha20poly1305_ietf_abytes() | 0),
          T = S.address;

      if (c.push(T), 0 === r._crypto_aead_xchacha20poly1305_ietf_encrypt(T, null, h, o, 0, p, i, 0, d, m, E)) {
        var Y = y(S, s);
        return g(c), Y;
      }

      b(c, "invalid usage");
    }

    function U(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "message")),
          o = e.length;
      c.push(h);
      var p = null,
          i = 0;
      null != t && (p = v(t = k(c, t, "additional_data")), i = t.length, c.push(p));
      var d = null;
      null != a && (d = v(a = k(c, a, "secret_nonce")), a.length, c.push(d)), _ = k(c, _, "public_nonce");

      var m,
          x = 0 | r._crypto_aead_xchacha20poly1305_ietf_npubbytes();

      _.length !== x && f(c, "invalid public_nonce length"), m = v(_), c.push(m), n = k(c, n, "key");

      var E,
          w = 0 | r._crypto_aead_xchacha20poly1305_ietf_keybytes();

      n.length !== w && f(c, "invalid key length"), E = v(n), c.push(E);
      var S = new u(0 | o),
          T = S.address;
      c.push(T);
      var Y = new u(0 | r._crypto_aead_xchacha20poly1305_ietf_abytes()),
          A = Y.address;

      if (c.push(A), 0 === r._crypto_aead_xchacha20poly1305_ietf_encrypt_detached(T, A, null, h, o, 0, p, i, 0, d, m, E)) {
        var B = y({
          ciphertext: S,
          mac: Y
        }, s);
        return g(c), B;
      }

      b(c, "invalid usage");
    }

    function O(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_aead_xchacha20poly1305_ietf_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_aead_xchacha20poly1305_ietf_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function R(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_auth_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_auth_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_auth(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function P(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_auth_hmacsha256_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_auth_hmacsha256_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_auth_hmacsha256(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function C(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_auth_hmacsha256_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_auth_hmacsha256_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function G(e, t, a) {
      var _ = [];
      e = k(_, e, "tag");

      var n,
          s = 0 | r._crypto_auth_hmacsha256_bytes();

      e.length !== s && f(_, "invalid tag length"), n = v(e), _.push(n);
      var c = v(t = k(_, t, "message")),
          h = t.length;
      _.push(c), a = k(_, a, "key");

      var o,
          p = 0 | r._crypto_auth_hmacsha256_keybytes();

      a.length !== p && f(_, "invalid key length"), o = v(a), _.push(o);

      var y = 0 == (0 | r._crypto_auth_hmacsha256_verify(n, c, h, 0, o));

      return g(_), y;
    }

    function D(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_auth_hmacsha512_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_auth_hmacsha512_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_auth_hmacsha512(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function X(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_auth_hmacsha512_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_auth_hmacsha512_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function V(e, t, a) {
      var _ = [];
      e = k(_, e, "tag");

      var n,
          s = 0 | r._crypto_auth_hmacsha512_bytes();

      e.length !== s && f(_, "invalid tag length"), n = v(e), _.push(n);
      var c = v(t = k(_, t, "message")),
          h = t.length;
      _.push(c), a = k(_, a, "key");

      var o,
          p = 0 | r._crypto_auth_hmacsha512_keybytes();

      a.length !== p && f(_, "invalid key length"), o = v(a), _.push(o);

      var y = 0 == (0 | r._crypto_auth_hmacsha512_verify(n, c, h, 0, o));

      return g(_), y;
    }

    function F(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_auth_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_auth_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function H(e, t, a) {
      var _ = [];
      e = k(_, e, "tag");

      var n,
          s = 0 | r._crypto_auth_bytes();

      e.length !== s && f(_, "invalid tag length"), n = v(e), _.push(n);
      var c = v(t = k(_, t, "message")),
          h = t.length;
      _.push(c), a = k(_, a, "key");

      var o,
          p = 0 | r._crypto_auth_keybytes();

      a.length !== p && f(_, "invalid key length"), o = v(a), _.push(o);

      var y = 0 == (0 | r._crypto_auth_verify(n, c, h, 0, o));

      return g(_), y;
    }

    function z(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "publicKey");

      var n,
          s = 0 | r._crypto_box_publickeybytes();

      e.length !== s && f(_, "invalid publicKey length"), n = v(e), _.push(n), t = k(_, t, "privateKey");

      var c,
          h = 0 | r._crypto_box_secretkeybytes();

      t.length !== h && f(_, "invalid privateKey length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_box_beforenmbytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_box_beforenm(p, n, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function j(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_box_curve25519xchacha20poly1305_publickeybytes()),
          _ = a.address;
      t.push(_);
      var n = new u(0 | r._crypto_box_curve25519xchacha20poly1305_secretkeybytes()),
          s = n.address;
      t.push(s), r._crypto_box_curve25519xchacha20poly1305_keypair(_, s);
      var c = y({
        publicKey: a,
        privateKey: n,
        keyType: "curve25519"
      }, e);
      return g(t), c;
    }

    function q(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "publicKey");

      var c,
          h = 0 | r._crypto_box_curve25519xchacha20poly1305_publickeybytes();

      t.length !== h && f(_, "invalid publicKey length"), c = v(t), _.push(c);
      var o = new u(s + r._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0),
          p = o.address;
      _.push(p), r._crypto_box_curve25519xchacha20poly1305_seal(p, n, s, 0, c);
      var i = y(o, a);
      return g(_), i;
    }

    function W(e, t, a, _) {
      var n = [];
      l(_), e = k(n, e, "ciphertext");

      var s,
          c = r._crypto_box_curve25519xchacha20poly1305_sealbytes(),
          h = e.length;

      h < c && f(n, "ciphertext is too short"), s = v(e), n.push(s), t = k(n, t, "publicKey");

      var o,
          p = 0 | r._crypto_box_curve25519xchacha20poly1305_publickeybytes();

      t.length !== p && f(n, "invalid publicKey length"), o = v(t), n.push(o), a = k(n, a, "secretKey");

      var i,
          d = 0 | r._crypto_box_curve25519xchacha20poly1305_secretkeybytes();

      a.length !== d && f(n, "invalid secretKey length"), i = v(a), n.push(i);
      var b = new u(h - r._crypto_box_curve25519xchacha20poly1305_sealbytes() | 0),
          m = b.address;
      n.push(m), r._crypto_box_curve25519xchacha20poly1305_seal_open(m, s, h, 0, o, i);
      var x = y(b, _);
      return g(n), x;
    }

    function J(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "message")),
          h = e.length;
      s.push(c), t = k(s, t, "nonce");

      var o,
          p = 0 | r._crypto_box_noncebytes();

      t.length !== p && f(s, "invalid nonce length"), o = v(t), s.push(o), a = k(s, a, "publicKey");

      var i,
          d = 0 | r._crypto_box_publickeybytes();

      a.length !== d && f(s, "invalid publicKey length"), i = v(a), s.push(i), _ = k(s, _, "privateKey");

      var m,
          x = 0 | r._crypto_box_secretkeybytes();

      _.length !== x && f(s, "invalid privateKey length"), m = v(_), s.push(m);
      var E = new u(0 | h),
          w = E.address;
      s.push(w);
      var S = new u(0 | r._crypto_box_macbytes()),
          T = S.address;

      if (s.push(T), 0 == (0 | r._crypto_box_detached(w, T, c, h, 0, o, i, m))) {
        var Y = y({
          ciphertext: E,
          mac: S
        }, n);
        return g(s), Y;
      }

      b(s, "invalid usage");
    }

    function Q(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "message")),
          h = e.length;
      s.push(c), t = k(s, t, "nonce");

      var o,
          p = 0 | r._crypto_box_noncebytes();

      t.length !== p && f(s, "invalid nonce length"), o = v(t), s.push(o), a = k(s, a, "publicKey");

      var i,
          d = 0 | r._crypto_box_publickeybytes();

      a.length !== d && f(s, "invalid publicKey length"), i = v(a), s.push(i), _ = k(s, _, "privateKey");

      var m,
          x = 0 | r._crypto_box_secretkeybytes();

      _.length !== x && f(s, "invalid privateKey length"), m = v(_), s.push(m);
      var E = new u(h + r._crypto_box_macbytes() | 0),
          w = E.address;

      if (s.push(w), 0 == (0 | r._crypto_box_easy(w, c, h, 0, o, i, m))) {
        var S = y(E, n);
        return g(s), S;
      }

      b(s, "invalid usage");
    }

    function Z(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_box_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "sharedKey");

      var p,
          i = 0 | r._crypto_box_beforenmbytes();

      a.length !== i && f(n, "invalid sharedKey length"), p = v(a), n.push(p);
      var d = new u(c + r._crypto_box_macbytes() | 0),
          m = d.address;

      if (n.push(m), 0 == (0 | r._crypto_box_easy_afternm(m, s, c, 0, h, p))) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "invalid usage");
    }

    function $(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_box_publickeybytes()),
          _ = a.address;
      t.push(_);
      var n = new u(0 | r._crypto_box_secretkeybytes()),
          s = n.address;

      if (t.push(s), 0 == (0 | r._crypto_box_keypair(_, s))) {
        var c = {
          publicKey: y(a, e),
          privateKey: y(n, e),
          keyType: "x25519"
        };
        return g(t), c;
      }

      b(t, "internal error");
    }

    function ee(e, t, a, _, n, s) {
      var c = [];
      l(s);
      var h = v(e = k(c, e, "ciphertext")),
          o = e.length;
      c.push(h), t = k(c, t, "mac");

      var p,
          i = 0 | r._crypto_box_macbytes();

      t.length !== i && f(c, "invalid mac length"), p = v(t), c.push(p), a = k(c, a, "nonce");

      var d,
          m = 0 | r._crypto_box_noncebytes();

      a.length !== m && f(c, "invalid nonce length"), d = v(a), c.push(d), _ = k(c, _, "publicKey");

      var x,
          E = 0 | r._crypto_box_publickeybytes();

      _.length !== E && f(c, "invalid publicKey length"), x = v(_), c.push(x), n = k(c, n, "privateKey");

      var w,
          S = 0 | r._crypto_box_secretkeybytes();

      n.length !== S && f(c, "invalid privateKey length"), w = v(n), c.push(w);
      var T = new u(0 | o),
          Y = T.address;

      if (c.push(Y), 0 == (0 | r._crypto_box_open_detached(Y, h, p, o, 0, d, x, w))) {
        var A = y(T, s);
        return g(c), A;
      }

      b(c, "incorrect key pair for the given ciphertext");
    }

    function te(e, t, a, _, n) {
      var s = [];
      l(n), e = k(s, e, "ciphertext");

      var c,
          h = r._crypto_box_macbytes(),
          o = e.length;

      o < h && f(s, "ciphertext is too short"), c = v(e), s.push(c), t = k(s, t, "nonce");

      var p,
          i = 0 | r._crypto_box_noncebytes();

      t.length !== i && f(s, "invalid nonce length"), p = v(t), s.push(p), a = k(s, a, "publicKey");

      var d,
          m = 0 | r._crypto_box_publickeybytes();

      a.length !== m && f(s, "invalid publicKey length"), d = v(a), s.push(d), _ = k(s, _, "privateKey");

      var x,
          E = 0 | r._crypto_box_secretkeybytes();

      _.length !== E && f(s, "invalid privateKey length"), x = v(_), s.push(x);
      var w = new u(o - r._crypto_box_macbytes() | 0),
          S = w.address;

      if (s.push(S), 0 == (0 | r._crypto_box_open_easy(S, c, o, 0, p, d, x))) {
        var T = y(w, n);
        return g(s), T;
      }

      b(s, "incorrect key pair for the given ciphertext");
    }

    function re(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "ciphertext")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_box_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "sharedKey");

      var p,
          i = 0 | r._crypto_box_beforenmbytes();

      a.length !== i && f(n, "invalid sharedKey length"), p = v(a), n.push(p);
      var d = new u(c - r._crypto_box_macbytes() | 0),
          m = d.address;

      if (n.push(m), 0 == (0 | r._crypto_box_open_easy_afternm(m, s, c, 0, h, p))) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "incorrect secret key for the given ciphertext");
    }

    function ae(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "publicKey");

      var c,
          h = 0 | r._crypto_box_publickeybytes();

      t.length !== h && f(_, "invalid publicKey length"), c = v(t), _.push(c);
      var o = new u(s + r._crypto_box_sealbytes() | 0),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_box_seal(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function _e(e, t, a, _) {
      var n = [];
      l(_), e = k(n, e, "ciphertext");

      var s,
          c = r._crypto_box_sealbytes(),
          h = e.length;

      h < c && f(n, "ciphertext is too short"), s = v(e), n.push(s), t = k(n, t, "publicKey");

      var o,
          p = 0 | r._crypto_box_publickeybytes();

      t.length !== p && f(n, "invalid publicKey length"), o = v(t), n.push(o), a = k(n, a, "privateKey");

      var i,
          d = 0 | r._crypto_box_secretkeybytes();

      a.length !== d && f(n, "invalid privateKey length"), i = v(a), n.push(i);
      var m = new u(h - r._crypto_box_sealbytes() | 0),
          x = m.address;

      if (n.push(x), 0 == (0 | r._crypto_box_seal_open(x, s, h, 0, o, i))) {
        var E = y(m, _);
        return g(n), E;
      }

      b(n, "incorrect key pair for the given ciphertext");
    }

    function ne(e, t) {
      var a = [];
      l(t), e = k(a, e, "seed");

      var _,
          n = 0 | r._crypto_box_seedbytes();

      e.length !== n && f(a, "invalid seed length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_box_publickeybytes()),
          c = s.address;
      a.push(c);
      var h = new u(0 | r._crypto_box_secretkeybytes()),
          o = h.address;

      if (a.push(o), 0 == (0 | r._crypto_box_seed_keypair(c, o, _))) {
        var p = {
          publicKey: y(s, t),
          privateKey: y(h, t),
          keyType: "x25519"
        };
        return g(a), p;
      }

      b(a, "invalid usage");
    }

    function se(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "p");

      var n,
          s = 0 | r._crypto_core_ristretto255_bytes();

      e.length !== s && f(_, "invalid p length"), n = v(e), _.push(n), t = k(_, t, "q");

      var c,
          h = 0 | r._crypto_core_ristretto255_bytes();

      t.length !== h && f(_, "invalid q length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_core_ristretto255_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_core_ristretto255_add(p, n, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "inputs is invalid element");
    }

    function ce(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "r"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_bytes()),
          s = n.address;

      if (a.push(s), 0 == (0 | r._crypto_core_ristretto255_from_hash(s, _))) {
        var c = y(n, t);
        return g(a), c;
      }

      b(a, "invalid usage");
    }

    function he(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "point"));

      e.length, a.push(_);

      var n = 1 == (0 | r._crypto_core_ristretto255_is_valid_point(_));

      return g(a), n;
    }

    function oe(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_core_ristretto255_bytes()),
          _ = a.address;
      t.push(_), r._crypto_core_ristretto255_random(_);
      var n = y(a, e);
      return g(t), n;
    }

    function pe(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "x");

      var n,
          s = 0 | r._crypto_core_ristretto255_scalarbytes();

      e.length !== s && f(_, "invalid x length"), n = v(e), _.push(n), t = k(_, t, "y");

      var c,
          h = 0 | r._crypto_core_ristretto255_scalarbytes();

      t.length !== h && f(_, "invalid y length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          p = o.address;
      _.push(p), r._crypto_core_ristretto255_scalar_add(p, n, c);
      var i = y(o, a);
      return g(_), i;
    }

    function ye(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "s"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          s = n.address;
      a.push(s), r._crypto_core_ristretto255_scalar_complement(s, _);
      var c = y(n, t);
      return g(a), c;
    }

    function ie(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "s"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          s = n.address;

      if (a.push(s), 0 == (0 | r._crypto_core_ristretto255_scalar_invert(s, _))) {
        var c = y(n, t);
        return g(a), c;
      }

      b(a, "invalid reciprocate");
    }

    function le(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "x");

      var n,
          s = 0 | r._crypto_core_ristretto255_scalarbytes();

      e.length !== s && f(_, "invalid x length"), n = v(e), _.push(n), t = k(_, t, "y");

      var c,
          h = 0 | r._crypto_core_ristretto255_scalarbytes();

      t.length !== h && f(_, "invalid y length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          p = o.address;
      _.push(p), r._crypto_core_ristretto255_scalar_mul(p, n, c);
      var i = y(o, a);
      return g(_), i;
    }

    function ue(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "s"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          s = n.address;
      a.push(s), r._crypto_core_ristretto255_scalar_negate(s, _);
      var c = y(n, t);
      return g(a), c;
    }

    function ve(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          _ = a.address;
      t.push(_), r._crypto_core_ristretto255_random(_);
      var n = y(a, e);
      return g(t), n;
    }

    function de(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "sample"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          s = n.address;
      a.push(s), r._crypto_core_ristretto255_scalar_reduce(s, _);
      var c = y(n, t);
      return g(a), c;
    }

    function ge(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "x");

      var n,
          s = 0 | r._crypto_core_ristretto255_scalarbytes();

      e.length !== s && f(_, "invalid x length"), n = v(e), _.push(n), t = k(_, t, "y");

      var c,
          h = 0 | r._crypto_core_ristretto255_scalarbytes();

      t.length !== h && f(_, "invalid y length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_core_ristretto255_scalarbytes()),
          p = o.address;
      _.push(p), r._crypto_core_ristretto255_scalar_sub(p, n, c);
      var i = y(o, a);
      return g(_), i;
    }

    function be(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "p");

      var n,
          s = 0 | r._crypto_core_ristretto255_bytes();

      e.length !== s && f(_, "invalid p length"), n = v(e), _.push(n), t = k(_, t, "q");

      var c,
          h = 0 | r._crypto_core_ristretto255_bytes();

      t.length !== h && f(_, "invalid q length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_core_ristretto255_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_core_ristretto255_sub(p, n, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "inputs is invalid element");
    }

    function fe(e, t, a, _) {
      var n = [];
      l(_), m(n, e, "hash_length"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(n, "hash_length must be an unsigned integer");
      var s = v(t = k(n, t, "message")),
          c = t.length;
      n.push(s);
      var h = null,
          o = 0;
      null != a && (h = v(a = k(n, a, "key")), o = a.length, n.push(h));
      var p = new u(e |= 0),
          i = p.address;

      if (n.push(i), 0 == (0 | r._crypto_generichash(i, e, s, c, 0, h, o))) {
        var d = y(p, _);
        return g(n), d;
      }

      b(n, "invalid usage");
    }

    function me(e, t, a, _, n) {
      var s = [];
      l(n), m(s, e, "subkey_len"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(s, "subkey_len must be an unsigned integer");
      var c = null,
          h = 0;
      null != t && (c = v(t = k(s, t, "key")), h = t.length, s.push(c)), a = k(s, a, "id");

      var o,
          p = 0 | r._crypto_generichash_blake2b_saltbytes();

      a.length !== p && f(s, "invalid id length"), o = v(a), s.push(o), _ = k(s, _, "ctx");

      var i,
          d = 0 | r._crypto_generichash_blake2b_personalbytes();

      _.length !== d && f(s, "invalid ctx length"), i = v(_), s.push(i);
      var x = new u(0 | e),
          E = x.address;

      if (s.push(E), 0 == (0 | r._crypto_generichash_blake2b_salt_personal(E, e, null, 0, 0, c, h, o, i))) {
        var w = y(x, n);
        return g(s), w;
      }

      b(s, "invalid usage");
    }

    function ke(e, t, a) {
      var _ = [];
      l(a), m(_, e, "state_address"), m(_, t, "hash_length"), ("number" != typeof t || (0 | t) !== t || t < 0) && f(_, "hash_length must be an unsigned integer");
      var n = new u(t |= 0),
          s = n.address;

      if (_.push(s), 0 == (0 | r._crypto_generichash_final(e, s, t))) {
        var c = (r._free(e), y(n, a));
        return g(_), c;
      }

      b(_, "invalid usage");
    }

    function xe(e, t, a) {
      var _ = [];
      l(a);
      var n = null,
          s = 0;
      null != e && (n = v(e = k(_, e, "key")), s = e.length, _.push(n)), m(_, t, "hash_length"), ("number" != typeof t || (0 | t) !== t || t < 0) && f(_, "hash_length must be an unsigned integer");
      var c = new u(357).address;

      if (0 == (0 | r._crypto_generichash_init(c, n, s, t))) {
        var h = c;
        return g(_), h;
      }

      b(_, "invalid usage");
    }

    function Ee(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_generichash_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_generichash_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function we(e, t, a) {
      var _ = [];
      l(a), m(_, e, "state_address");
      var n = v(t = k(_, t, "message_chunk")),
          s = t.length;
      _.push(n), 0 != (0 | r._crypto_generichash_update(e, n, s)) && b(_, "invalid usage"), g(_);
    }

    function Se(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "message")),
          n = e.length;

      a.push(_);
      var s = new u(0 | r._crypto_hash_bytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_hash(c, _, n, 0))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid usage");
    }

    function Te(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "message")),
          n = e.length;

      a.push(_);
      var s = new u(0 | r._crypto_hash_sha256_bytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_hash_sha256(c, _, n, 0))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid usage");
    }

    function Ye(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "message")),
          n = e.length;

      a.push(_);
      var s = new u(0 | r._crypto_hash_sha512_bytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_hash_sha512(c, _, n, 0))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid usage");
    }

    function Ae(e, t, a, _, s) {
      var c = [];
      l(s), m(c, e, "subkey_len"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(c, "subkey_len must be an unsigned integer"), m(c, t, "subkey_id"), ("number" != typeof t || (0 | t) !== t || t < 0) && f(c, "subkey_id must be an unsigned integer"), "string" != typeof a && f(c, "ctx must be a string");
      var h = v(a = n(a + "\0"));
      a.length, c.push(h), _ = k(c, _, "key");

      var o,
          p = 0 | r._crypto_kdf_keybytes();

      _.length !== p && f(c, "invalid key length"), o = v(_), c.push(o);
      var i = new u(0 | e),
          d = i.address;
      c.push(d), r._crypto_kdf_derive_from_key(d, e, t, t >>> 24 >>> 8, h, o);
      var b = y(i, s);
      return g(c), b;
    }

    function Be(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_kdf_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_kdf_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function Ke(e, t, a, _) {
      var n = [];
      l(_), e = k(n, e, "clientPublicKey");

      var s,
          c = 0 | r._crypto_kx_publickeybytes();

      e.length !== c && f(n, "invalid clientPublicKey length"), s = v(e), n.push(s), t = k(n, t, "clientSecretKey");

      var h,
          o = 0 | r._crypto_kx_secretkeybytes();

      t.length !== o && f(n, "invalid clientSecretKey length"), h = v(t), n.push(h), a = k(n, a, "serverPublicKey");

      var p,
          i = 0 | r._crypto_kx_publickeybytes();

      a.length !== i && f(n, "invalid serverPublicKey length"), p = v(a), n.push(p);
      var d = new u(0 | r._crypto_kx_sessionkeybytes()),
          m = d.address;
      n.push(m);
      var x = new u(0 | r._crypto_kx_sessionkeybytes()),
          E = x.address;

      if (n.push(E), 0 == (0 | r._crypto_kx_client_session_keys(m, E, s, h, p))) {
        var w = y({
          sharedRx: d,
          sharedTx: x
        }, _);
        return g(n), w;
      }

      b(n, "invalid usage");
    }

    function Ie(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_kx_publickeybytes()),
          _ = a.address;
      t.push(_);
      var n = new u(0 | r._crypto_kx_secretkeybytes()),
          s = n.address;

      if (t.push(s), 0 == (0 | r._crypto_kx_keypair(_, s))) {
        var c = {
          publicKey: y(a, e),
          privateKey: y(n, e),
          keyType: "x25519"
        };
        return g(t), c;
      }

      b(t, "internal error");
    }

    function Me(e, t) {
      var a = [];
      l(t), e = k(a, e, "seed");

      var _,
          n = 0 | r._crypto_kx_seedbytes();

      e.length !== n && f(a, "invalid seed length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_kx_publickeybytes()),
          c = s.address;
      a.push(c);
      var h = new u(0 | r._crypto_kx_secretkeybytes()),
          o = h.address;

      if (a.push(o), 0 == (0 | r._crypto_kx_seed_keypair(c, o, _))) {
        var p = {
          publicKey: y(s, t),
          privateKey: y(h, t),
          keyType: "x25519"
        };
        return g(a), p;
      }

      b(a, "internal error");
    }

    function Le(e, t, a, _) {
      var n = [];
      l(_), e = k(n, e, "serverPublicKey");

      var s,
          c = 0 | r._crypto_kx_publickeybytes();

      e.length !== c && f(n, "invalid serverPublicKey length"), s = v(e), n.push(s), t = k(n, t, "serverSecretKey");

      var h,
          o = 0 | r._crypto_kx_secretkeybytes();

      t.length !== o && f(n, "invalid serverSecretKey length"), h = v(t), n.push(h), a = k(n, a, "clientPublicKey");

      var p,
          i = 0 | r._crypto_kx_publickeybytes();

      a.length !== i && f(n, "invalid clientPublicKey length"), p = v(a), n.push(p);
      var d = new u(0 | r._crypto_kx_sessionkeybytes()),
          m = d.address;
      n.push(m);
      var x = new u(0 | r._crypto_kx_sessionkeybytes()),
          E = x.address;

      if (n.push(E), 0 == (0 | r._crypto_kx_server_session_keys(m, E, s, h, p))) {
        var w = y({
          sharedRx: d,
          sharedTx: x
        }, _);
        return g(n), w;
      }

      b(n, "invalid usage");
    }

    function Ne(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_onetimeauth_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_onetimeauth_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_onetimeauth(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function Ue(e, t) {
      var a = [];
      l(t), m(a, e, "state_address");

      var _ = new u(0 | r._crypto_onetimeauth_bytes()),
          n = _.address;

      if (a.push(n), 0 == (0 | r._crypto_onetimeauth_final(e, n))) {
        var s = (r._free(e), y(_, t));
        return g(a), s;
      }

      b(a, "invalid usage");
    }

    function Oe(e, t) {
      var a = [];
      l(t);
      var _ = null;
      null != e && (_ = v(e = k(a, e, "key")), e.length, a.push(_));
      var n = new u(144).address;

      if (0 == (0 | r._crypto_onetimeauth_init(n, _))) {
        var s = n;
        return g(a), s;
      }

      b(a, "invalid usage");
    }

    function Re(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_onetimeauth_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_onetimeauth_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function Pe(e, t, a) {
      var _ = [];
      l(a), m(_, e, "state_address");
      var n = v(t = k(_, t, "message_chunk")),
          s = t.length;
      _.push(n), 0 != (0 | r._crypto_onetimeauth_update(e, n, s)) && b(_, "invalid usage"), g(_);
    }

    function Ce(e, t, a) {
      var _ = [];
      e = k(_, e, "hash");

      var n,
          s = 0 | r._crypto_onetimeauth_bytes();

      e.length !== s && f(_, "invalid hash length"), n = v(e), _.push(n);
      var c = v(t = k(_, t, "message")),
          h = t.length;
      _.push(c), a = k(_, a, "key");

      var o,
          p = 0 | r._crypto_onetimeauth_keybytes();

      a.length !== p && f(_, "invalid key length"), o = v(a), _.push(o);

      var y = 0 == (0 | r._crypto_onetimeauth_verify(n, c, h, 0, o));

      return g(_), y;
    }

    function Ge(e, t, a, _, n, s, c) {
      var h = [];
      l(c), m(h, e, "keyLength"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(h, "keyLength must be an unsigned integer");
      var o = v(t = k(h, t, "password")),
          p = t.length;
      h.push(o), a = k(h, a, "salt");

      var i,
          d = 0 | r._crypto_pwhash_saltbytes();

      a.length !== d && f(h, "invalid salt length"), i = v(a), h.push(i), m(h, _, "opsLimit"), ("number" != typeof _ || (0 | _) !== _ || _ < 0) && f(h, "opsLimit must be an unsigned integer"), m(h, n, "memLimit"), ("number" != typeof n || (0 | n) !== n || n < 0) && f(h, "memLimit must be an unsigned integer"), m(h, s, "algorithm"), ("number" != typeof s || (0 | s) !== s || s < 0) && f(h, "algorithm must be an unsigned integer");
      var x = new u(0 | e),
          E = x.address;

      if (h.push(E), 0 == (0 | r._crypto_pwhash(E, e, 0, o, p, 0, i, _, 0, n, s))) {
        var w = y(x, c);
        return g(h), w;
      }

      b(h, "invalid usage");
    }

    function De(e, t, a, _, n, s) {
      var c = [];
      l(s), m(c, e, "keyLength"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(c, "keyLength must be an unsigned integer");
      var h = v(t = k(c, t, "password")),
          o = t.length;
      c.push(h), a = k(c, a, "salt");

      var p,
          i = 0 | r._crypto_pwhash_scryptsalsa208sha256_saltbytes();

      a.length !== i && f(c, "invalid salt length"), p = v(a), c.push(p), m(c, _, "opsLimit"), ("number" != typeof _ || (0 | _) !== _ || _ < 0) && f(c, "opsLimit must be an unsigned integer"), m(c, n, "memLimit"), ("number" != typeof n || (0 | n) !== n || n < 0) && f(c, "memLimit must be an unsigned integer");
      var d = new u(0 | e),
          x = d.address;

      if (c.push(x), 0 == (0 | r._crypto_pwhash_scryptsalsa208sha256(x, e, 0, h, o, 0, p, _, 0, n))) {
        var E = y(d, s);
        return g(c), E;
      }

      b(c, "invalid usage");
    }

    function Xe(e, t, a, _, n, s, c) {
      var h = [];
      l(c);
      var o = v(e = k(h, e, "password")),
          p = e.length;
      h.push(o);
      var i = v(t = k(h, t, "salt")),
          d = t.length;
      h.push(i), m(h, a, "opsLimit"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(h, "opsLimit must be an unsigned integer"), m(h, _, "r"), ("number" != typeof _ || (0 | _) !== _ || _ < 0) && f(h, "r must be an unsigned integer"), m(h, n, "p"), ("number" != typeof n || (0 | n) !== n || n < 0) && f(h, "p must be an unsigned integer"), m(h, s, "keyLength"), ("number" != typeof s || (0 | s) !== s || s < 0) && f(h, "keyLength must be an unsigned integer");
      var x = new u(0 | s),
          E = x.address;

      if (h.push(E), 0 == (0 | r._crypto_pwhash_scryptsalsa208sha256_ll(o, p, i, d, a, 0, _, n, E, s))) {
        var w = y(x, c);
        return g(h), w;
      }

      b(h, "invalid usage");
    }

    function Ve(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "password")),
          c = e.length;
      n.push(s), m(n, t, "opsLimit"), ("number" != typeof t || (0 | t) !== t || t < 0) && f(n, "opsLimit must be an unsigned integer"), m(n, a, "memLimit"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(n, "memLimit must be an unsigned integer");
      var h = new u(0 | r._crypto_pwhash_scryptsalsa208sha256_strbytes()).address;

      if (n.push(h), 0 == (0 | r._crypto_pwhash_scryptsalsa208sha256_str(h, s, c, 0, t, 0, a))) {
        var o = r.UTF8ToString(h);
        return g(n), o;
      }

      b(n, "invalid usage");
    }

    function Fe(e, t, a) {
      var _ = [];
      l(a), "string" != typeof e && f(_, "hashed_password must be a string");
      var s = v(e = n(e + "\0"));
      e.length, _.push(s);
      var c = v(t = k(_, t, "password")),
          h = t.length;

      _.push(c);

      var o = 0 == (0 | r._crypto_pwhash_scryptsalsa208sha256_str_verify(s, c, h, 0));

      return g(_), o;
    }

    function He(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "password")),
          c = e.length;
      n.push(s), m(n, t, "opsLimit"), ("number" != typeof t || (0 | t) !== t || t < 0) && f(n, "opsLimit must be an unsigned integer"), m(n, a, "memLimit"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(n, "memLimit must be an unsigned integer");
      var h = new u(0 | r._crypto_pwhash_strbytes()).address;

      if (n.push(h), 0 == (0 | r._crypto_pwhash_str(h, s, c, 0, t, 0, a))) {
        var o = r.UTF8ToString(h);
        return g(n), o;
      }

      b(n, "invalid usage");
    }

    function ze(e, t, a) {
      var _ = [];
      l(a), "string" != typeof e && f(_, "hashed_password must be a string");
      var s = v(e = n(e + "\0"));
      e.length, _.push(s);
      var c = v(t = k(_, t, "password")),
          h = t.length;

      _.push(c);

      var o = 0 == (0 | r._crypto_pwhash_str_verify(s, c, h, 0));

      return g(_), o;
    }

    function je(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "privateKey");

      var n,
          s = 0 | r._crypto_scalarmult_scalarbytes();

      e.length !== s && f(_, "invalid privateKey length"), n = v(e), _.push(n), t = k(_, t, "publicKey");

      var c,
          h = 0 | r._crypto_scalarmult_scalarbytes();

      t.length !== h && f(_, "invalid publicKey length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_scalarmult_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_scalarmult(p, n, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "weak public key");
    }

    function qe(e, t) {
      var a = [];
      l(t), e = k(a, e, "privateKey");

      var _,
          n = 0 | r._crypto_scalarmult_scalarbytes();

      e.length !== n && f(a, "invalid privateKey length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_scalarmult_scalarbytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_scalarmult_base(c, _))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "insecure scalar");
    }

    function We(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "scalar");

      var n,
          s = 0 | r._crypto_scalarmult_ristretto255_scalarbytes();

      e.length !== s && f(_, "invalid scalar length"), n = v(e), _.push(n), t = k(_, t, "privateKey");

      var c,
          h = 0 | r._crypto_scalarmult_ristretto255_bytes();

      t.length !== h && f(_, "invalid privateKey length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_scalarmult_ristretto255_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_scalarmult_ristretto255(p, n, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "input is zero element");
    }

    function Je(e, t) {
      var a = [];
      l(t);

      var _ = v(e = k(a, e, "scalar"));

      e.length, a.push(_);
      var n = new u(0 | r._crypto_core_ristretto255_bytes()),
          s = n.address;

      if (a.push(s), 0 == (0 | r._crypto_scalarmult_ristretto255_base(s, _))) {
        var c = y(n, t);
        return g(a), c;
      }

      b(a, "scalar is 0");
    }

    function Qe(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_secretbox_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "key");

      var p,
          i = 0 | r._crypto_secretbox_keybytes();

      a.length !== i && f(n, "invalid key length"), p = v(a), n.push(p);
      var d = new u(0 | c),
          m = d.address;
      n.push(m);
      var x = new u(0 | r._crypto_secretbox_macbytes()),
          E = x.address;

      if (n.push(E), 0 == (0 | r._crypto_secretbox_detached(m, E, s, c, 0, h, p))) {
        var w = y({
          mac: x,
          cipher: d
        }, _);
        return g(n), w;
      }

      b(n, "invalid usage");
    }

    function Ze(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_secretbox_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "key");

      var p,
          i = 0 | r._crypto_secretbox_keybytes();

      a.length !== i && f(n, "invalid key length"), p = v(a), n.push(p);
      var d = new u(c + r._crypto_secretbox_macbytes() | 0),
          m = d.address;

      if (n.push(m), 0 == (0 | r._crypto_secretbox_easy(m, s, c, 0, h, p))) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "invalid usage");
    }

    function $e(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_secretbox_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_secretbox_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function et(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "ciphertext")),
          h = e.length;
      s.push(c), t = k(s, t, "mac");

      var o,
          p = 0 | r._crypto_secretbox_macbytes();

      t.length !== p && f(s, "invalid mac length"), o = v(t), s.push(o), a = k(s, a, "nonce");

      var i,
          d = 0 | r._crypto_secretbox_noncebytes();

      a.length !== d && f(s, "invalid nonce length"), i = v(a), s.push(i), _ = k(s, _, "key");

      var m,
          x = 0 | r._crypto_secretbox_keybytes();

      _.length !== x && f(s, "invalid key length"), m = v(_), s.push(m);
      var E = new u(0 | h),
          w = E.address;

      if (s.push(w), 0 == (0 | r._crypto_secretbox_open_detached(w, c, o, h, 0, i, m))) {
        var S = y(E, n);
        return g(s), S;
      }

      b(s, "wrong secret key for the given ciphertext");
    }

    function tt(e, t, a, _) {
      var n = [];
      l(_), e = k(n, e, "ciphertext");

      var s,
          c = r._crypto_secretbox_macbytes(),
          h = e.length;

      h < c && f(n, "ciphertext is too short"), s = v(e), n.push(s), t = k(n, t, "nonce");

      var o,
          p = 0 | r._crypto_secretbox_noncebytes();

      t.length !== p && f(n, "invalid nonce length"), o = v(t), n.push(o), a = k(n, a, "key");

      var i,
          d = 0 | r._crypto_secretbox_keybytes();

      a.length !== d && f(n, "invalid key length"), i = v(a), n.push(i);
      var m = new u(h - r._crypto_secretbox_macbytes() | 0),
          x = m.address;

      if (n.push(x), 0 == (0 | r._crypto_secretbox_open_easy(x, s, h, 0, o, i))) {
        var E = y(m, _);
        return g(n), E;
      }

      b(n, "wrong secret key for the given ciphertext");
    }

    function rt(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "header");

      var n,
          s = 0 | r._crypto_secretstream_xchacha20poly1305_headerbytes();

      e.length !== s && f(_, "invalid header length"), n = v(e), _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_secretstream_xchacha20poly1305_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(52).address;

      if (0 == (0 | r._crypto_secretstream_xchacha20poly1305_init_pull(o, n, c))) {
        var p = o;
        return g(_), p;
      }

      b(_, "invalid usage");
    }

    function at(e, t) {
      var a = [];
      l(t), e = k(a, e, "key");

      var _,
          n = 0 | r._crypto_secretstream_xchacha20poly1305_keybytes();

      e.length !== n && f(a, "invalid key length"), _ = v(e), a.push(_);
      var s = new u(52).address,
          c = new u(0 | r._crypto_secretstream_xchacha20poly1305_headerbytes()),
          h = c.address;

      if (a.push(h), 0 == (0 | r._crypto_secretstream_xchacha20poly1305_init_push(s, h, _))) {
        var o = {
          state: s,
          header: y(c, t)
        };
        return g(a), o;
      }

      b(a, "invalid usage");
    }

    function _t(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_secretstream_xchacha20poly1305_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_secretstream_xchacha20poly1305_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function nt(e, t, a, _) {
      var n = [];
      l(_), m(n, e, "state_address"), t = k(n, t, "cipher");

      var s,
          c = r._crypto_secretstream_xchacha20poly1305_abytes(),
          h = t.length;

      h < c && f(n, "cipher is too short"), s = v(t), n.push(s);
      var o = null,
          p = 0;
      null != a && (o = v(a = k(n, a, "ad")), p = a.length, n.push(o));
      var i = new u(h - r._crypto_secretstream_xchacha20poly1305_abytes() | 0),
          b = i.address;
      n.push(b);
      var x,
          E = (x = d(1), n.push(x), (E = 0 === r._crypto_secretstream_xchacha20poly1305_pull(e, b, 0, x, s, h, 0, o, p) && {
        tag: r.HEAPU8[x],
        message: i
      }) && {
        message: y(E.message, _),
        tag: E.tag
      });
      return g(n), E;
    }

    function st(e, t, a, _, n) {
      var s = [];
      l(n), m(s, e, "state_address");
      var c = v(t = k(s, t, "message_chunk")),
          h = t.length;
      s.push(c);
      var o = null,
          p = 0;
      null != a && (o = v(a = k(s, a, "ad")), p = a.length, s.push(o)), m(s, _, "tag"), ("number" != typeof _ || (0 | _) !== _ || _ < 0) && f(s, "tag must be an unsigned integer");
      var i = new u(h + r._crypto_secretstream_xchacha20poly1305_abytes() | 0),
          d = i.address;

      if (s.push(d), 0 == (0 | r._crypto_secretstream_xchacha20poly1305_push(e, d, 0, c, h, 0, o, p, 0, _))) {
        var x = y(i, n);
        return g(s), x;
      }

      b(s, "invalid usage");
    }

    function ct(e, t) {
      var a = [];
      return l(t), m(a, e, "state_address"), r._crypto_secretstream_xchacha20poly1305_rekey(e), g(a), !0;
    }

    function ht(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_shorthash_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_shorthash_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_shorthash(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function ot(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_shorthash_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_shorthash_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function pt(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "key");

      var c,
          h = 0 | r._crypto_shorthash_siphashx24_keybytes();

      t.length !== h && f(_, "invalid key length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_shorthash_siphashx24_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_shorthash_siphashx24(p, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function yt(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "privateKey");

      var c,
          h = 0 | r._crypto_sign_secretkeybytes();

      t.length !== h && f(_, "invalid privateKey length"), c = v(t), _.push(c);
      var o = new u(e.length + r._crypto_sign_bytes() | 0),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_sign(p, null, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function it(e, t, a) {
      var _ = [];
      l(a);
      var n = v(e = k(_, e, "message")),
          s = e.length;
      _.push(n), t = k(_, t, "privateKey");

      var c,
          h = 0 | r._crypto_sign_secretkeybytes();

      t.length !== h && f(_, "invalid privateKey length"), c = v(t), _.push(c);
      var o = new u(0 | r._crypto_sign_bytes()),
          p = o.address;

      if (_.push(p), 0 == (0 | r._crypto_sign_detached(p, null, n, s, 0, c))) {
        var i = y(o, a);
        return g(_), i;
      }

      b(_, "invalid usage");
    }

    function lt(e, t) {
      var a = [];
      l(t), e = k(a, e, "edPk");

      var _,
          n = 0 | r._crypto_sign_publickeybytes();

      e.length !== n && f(a, "invalid edPk length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_scalarmult_scalarbytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_sign_ed25519_pk_to_curve25519(c, _))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid key");
    }

    function ut(e, t) {
      var a = [];
      l(t), e = k(a, e, "edSk");

      var _,
          n = 0 | r._crypto_sign_secretkeybytes();

      e.length !== n && f(a, "invalid edSk length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_scalarmult_scalarbytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_sign_ed25519_sk_to_curve25519(c, _))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid key");
    }

    function vt(e, t) {
      var a = [];
      l(t), e = k(a, e, "privateKey");

      var _,
          n = 0 | r._crypto_sign_secretkeybytes();

      e.length !== n && f(a, "invalid privateKey length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_sign_publickeybytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_sign_ed25519_sk_to_pk(c, _))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid key");
    }

    function dt(e, t) {
      var a = [];
      l(t), e = k(a, e, "privateKey");

      var _,
          n = 0 | r._crypto_sign_secretkeybytes();

      e.length !== n && f(a, "invalid privateKey length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_sign_seedbytes()),
          c = s.address;

      if (a.push(c), 0 == (0 | r._crypto_sign_ed25519_sk_to_seed(c, _))) {
        var h = y(s, t);
        return g(a), h;
      }

      b(a, "invalid key");
    }

    function gt(e, t, a) {
      var _ = [];
      l(a), m(_, e, "state_address"), t = k(_, t, "privateKey");

      var n,
          s = 0 | r._crypto_sign_secretkeybytes();

      t.length !== s && f(_, "invalid privateKey length"), n = v(t), _.push(n);
      var c = new u(0 | r._crypto_sign_bytes()),
          h = c.address;

      if (_.push(h), 0 == (0 | r._crypto_sign_final_create(e, h, null, n))) {
        var o = (r._free(e), y(c, a));
        return g(_), o;
      }

      b(_, "invalid usage");
    }

    function bt(e, t, a, _) {
      var n = [];
      l(_), m(n, e, "state_address"), t = k(n, t, "signature");

      var s,
          c = 0 | r._crypto_sign_bytes();

      t.length !== c && f(n, "invalid signature length"), s = v(t), n.push(s), a = k(n, a, "publicKey");

      var h,
          o = 0 | r._crypto_sign_publickeybytes();

      a.length !== o && f(n, "invalid publicKey length"), h = v(a), n.push(h);

      var p = 0 == (0 | r._crypto_sign_final_verify(e, s, h));

      return g(n), p;
    }

    function ft(e) {
      var t = [];
      l(e);
      var a = new u(208).address;

      if (0 == (0 | r._crypto_sign_init(a))) {
        var _ = a;
        return g(t), _;
      }

      b(t, "internal error");
    }

    function mt(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_sign_publickeybytes()),
          _ = a.address;
      t.push(_);
      var n = new u(0 | r._crypto_sign_secretkeybytes()),
          s = n.address;

      if (t.push(s), 0 == (0 | r._crypto_sign_keypair(_, s))) {
        var c = {
          publicKey: y(a, e),
          privateKey: y(n, e),
          keyType: "ed25519"
        };
        return g(t), c;
      }

      b(t, "internal error");
    }

    function kt(e, t, a) {
      var _ = [];
      l(a), e = k(_, e, "signedMessage");

      var n,
          s = r._crypto_sign_bytes(),
          c = e.length;

      c < s && f(_, "signedMessage is too short"), n = v(e), _.push(n), t = k(_, t, "publicKey");

      var h,
          o = 0 | r._crypto_sign_publickeybytes();

      t.length !== o && f(_, "invalid publicKey length"), h = v(t), _.push(h);
      var p = new u(c - r._crypto_sign_bytes() | 0),
          i = p.address;

      if (_.push(i), 0 == (0 | r._crypto_sign_open(i, null, n, c, 0, h))) {
        var d = y(p, a);
        return g(_), d;
      }

      b(_, "incorrect signature for the given public key");
    }

    function xt(e, t) {
      var a = [];
      l(t), e = k(a, e, "seed");

      var _,
          n = 0 | r._crypto_sign_seedbytes();

      e.length !== n && f(a, "invalid seed length"), _ = v(e), a.push(_);
      var s = new u(0 | r._crypto_sign_publickeybytes()),
          c = s.address;
      a.push(c);
      var h = new u(0 | r._crypto_sign_secretkeybytes()),
          o = h.address;

      if (a.push(o), 0 == (0 | r._crypto_sign_seed_keypair(c, o, _))) {
        var p = {
          publicKey: y(s, t),
          privateKey: y(h, t),
          keyType: "ed25519"
        };
        return g(a), p;
      }

      b(a, "invalid usage");
    }

    function Et(e, t, a) {
      var _ = [];
      l(a), m(_, e, "state_address");
      var n = v(t = k(_, t, "message_chunk")),
          s = t.length;
      _.push(n), 0 != (0 | r._crypto_sign_update(e, n, s)) && b(_, "invalid usage"), g(_);
    }

    function wt(e, t, a) {
      var _ = [];
      e = k(_, e, "signature");

      var n,
          s = 0 | r._crypto_sign_bytes();

      e.length !== s && f(_, "invalid signature length"), n = v(e), _.push(n);
      var c = v(t = k(_, t, "message")),
          h = t.length;
      _.push(c), a = k(_, a, "publicKey");

      var o,
          p = 0 | r._crypto_sign_publickeybytes();

      a.length !== p && f(_, "invalid publicKey length"), o = v(a), _.push(o);

      var y = 0 == (0 | r._crypto_sign_verify_detached(n, c, h, 0, o));

      return g(_), y;
    }

    function St(e, t, a, _) {
      var n = [];
      l(_), m(n, e, "outLength"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(n, "outLength must be an unsigned integer"), t = k(n, t, "key");

      var s,
          c = 0 | r._crypto_stream_chacha20_keybytes();

      t.length !== c && f(n, "invalid key length"), s = v(t), n.push(s), a = k(n, a, "nonce");

      var h,
          o = 0 | r._crypto_stream_chacha20_noncebytes();

      a.length !== o && f(n, "invalid nonce length"), h = v(a), n.push(h);
      var p = new u(0 | e),
          i = p.address;
      n.push(i), r._crypto_stream_chacha20(i, e, 0, h, s);
      var d = y(p, _);
      return g(n), d;
    }

    function Tt(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "input_message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_stream_chacha20_ietf_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "key");

      var p,
          i = 0 | r._crypto_stream_chacha20_ietf_keybytes();

      a.length !== i && f(n, "invalid key length"), p = v(a), n.push(p);
      var d = new u(0 | c),
          m = d.address;

      if (n.push(m), 0 === r._crypto_stream_chacha20_ietf_xor(m, s, c, 0, h, p)) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "invalid usage");
    }

    function Yt(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "input_message")),
          h = e.length;
      s.push(c), t = k(s, t, "nonce");

      var o,
          p = 0 | r._crypto_stream_chacha20_ietf_noncebytes();

      t.length !== p && f(s, "invalid nonce length"), o = v(t), s.push(o), m(s, a, "nonce_increment"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(s, "nonce_increment must be an unsigned integer"), _ = k(s, _, "key");

      var i,
          d = 0 | r._crypto_stream_chacha20_ietf_keybytes();

      _.length !== d && f(s, "invalid key length"), i = v(_), s.push(i);
      var x = new u(0 | h),
          E = x.address;

      if (s.push(E), 0 === r._crypto_stream_chacha20_ietf_xor_ic(E, c, h, 0, o, a, 0, i)) {
        var w = y(x, n);
        return g(s), w;
      }

      b(s, "invalid usage");
    }

    function At(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_stream_chacha20_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_stream_chacha20_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function Bt(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "input_message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_stream_chacha20_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "key");

      var p,
          i = 0 | r._crypto_stream_chacha20_keybytes();

      a.length !== i && f(n, "invalid key length"), p = v(a), n.push(p);
      var d = new u(0 | c),
          m = d.address;

      if (n.push(m), 0 === r._crypto_stream_chacha20_xor(m, s, c, 0, h, p)) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "invalid usage");
    }

    function Kt(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "input_message")),
          h = e.length;
      s.push(c), t = k(s, t, "nonce");

      var o,
          p = 0 | r._crypto_stream_chacha20_noncebytes();

      t.length !== p && f(s, "invalid nonce length"), o = v(t), s.push(o), m(s, a, "nonce_increment"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(s, "nonce_increment must be an unsigned integer"), _ = k(s, _, "key");

      var i,
          d = 0 | r._crypto_stream_chacha20_keybytes();

      _.length !== d && f(s, "invalid key length"), i = v(_), s.push(i);
      var x = new u(0 | h),
          E = x.address;

      if (s.push(E), 0 === r._crypto_stream_chacha20_xor_ic(E, c, h, 0, o, a, 0, i)) {
        var w = y(x, n);
        return g(s), w;
      }

      b(s, "invalid usage");
    }

    function It(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_stream_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_stream_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function Mt(e) {
      var t = [];
      l(e);
      var a = new u(0 | r._crypto_stream_xchacha20_keybytes()),
          _ = a.address;
      t.push(_), r._crypto_stream_xchacha20_keygen(_);
      var n = y(a, e);
      return g(t), n;
    }

    function Lt(e, t, a, _) {
      var n = [];
      l(_);
      var s = v(e = k(n, e, "input_message")),
          c = e.length;
      n.push(s), t = k(n, t, "nonce");

      var h,
          o = 0 | r._crypto_stream_xchacha20_noncebytes();

      t.length !== o && f(n, "invalid nonce length"), h = v(t), n.push(h), a = k(n, a, "key");

      var p,
          i = 0 | r._crypto_stream_xchacha20_keybytes();

      a.length !== i && f(n, "invalid key length"), p = v(a), n.push(p);
      var d = new u(0 | c),
          m = d.address;

      if (n.push(m), 0 === r._crypto_stream_xchacha20_xor(m, s, c, 0, h, p)) {
        var x = y(d, _);
        return g(n), x;
      }

      b(n, "invalid usage");
    }

    function Nt(e, t, a, _, n) {
      var s = [];
      l(n);
      var c = v(e = k(s, e, "input_message")),
          h = e.length;
      s.push(c), t = k(s, t, "nonce");

      var o,
          p = 0 | r._crypto_stream_xchacha20_noncebytes();

      t.length !== p && f(s, "invalid nonce length"), o = v(t), s.push(o), m(s, a, "nonce_increment"), ("number" != typeof a || (0 | a) !== a || a < 0) && f(s, "nonce_increment must be an unsigned integer"), _ = k(s, _, "key");

      var i,
          d = 0 | r._crypto_stream_xchacha20_keybytes();

      _.length !== d && f(s, "invalid key length"), i = v(_), s.push(i);
      var x = new u(0 | h),
          E = x.address;

      if (s.push(E), 0 === r._crypto_stream_xchacha20_xor_ic(E, c, h, 0, o, a, 0, i)) {
        var w = y(x, n);
        return g(s), w;
      }

      b(s, "invalid usage");
    }

    function Ut(e, t) {
      var a = [];
      l(t), m(a, e, "length"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(a, "length must be an unsigned integer");

      var _ = new u(0 | e),
          n = _.address;

      a.push(n), r._randombytes_buf(n, e);
      var s = y(_, t);
      return g(a), s;
    }

    function Ot(e, t, a) {
      var _ = [];
      l(a), m(_, e, "length"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(_, "length must be an unsigned integer"), t = k(_, t, "seed");

      var n,
          s = 0 | r._randombytes_seedbytes();

      t.length !== s && f(_, "invalid seed length"), n = v(t), _.push(n);
      var c = new u(0 | e),
          h = c.address;
      _.push(h), r._randombytes_buf_deterministic(h, e, n);
      var o = y(c, a);
      return g(_), o;
    }

    function Rt(e) {
      l(e), r._randombytes_close();
    }

    function Pt(e) {
      l(e);
      var t = r._randombytes_random() >>> 0;
      return g([]), t;
    }

    function Ct(e, t) {
      var a = [];
      l(t);

      for (var _ = r._malloc(24), n = 0; n < 6; n++) {
        r.setValue(_ + 4 * n, r.Runtime.addFunction(e[["implementation_name", "random", "stir", "uniform", "buf", "close"][n]]), "i32");
      }

      0 != (0 | r._randombytes_set_implementation(_)) && b(a, "unsupported implementation"), g(a);
    }

    function Gt(e) {
      l(e), r._randombytes_stir();
    }

    function Dt(e, t) {
      var a = [];
      l(t), m(a, e, "upper_bound"), ("number" != typeof e || (0 | e) !== e || e < 0) && f(a, "upper_bound must be an unsigned integer");

      var _ = r._randombytes_uniform(e) >>> 0;

      return g(a), _;
    }

    function Xt() {
      var e = r._sodium_version_string(),
          t = r.UTF8ToString(e);

      return g([]), t;
    }

    return u.prototype.to_Uint8Array = function () {
      var e = new Uint8Array(this.length);
      return e.set(r.HEAPU8.subarray(this.address, this.address + this.length)), e;
    }, e.add = function (e, t) {
      if (!(e instanceof Uint8Array && t instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can added");
      var r = e.length,
          a = 0,
          _ = 0;
      if (t.length != e.length) throw new TypeError("Arguments must have the same length");

      for (_ = 0; _ < r; _++) {
        a >>= 8, a += e[_] + t[_], e[_] = 255 & a;
      }
    }, e.base64_variants = h, e.compare = function (e, t) {
      if (!(e instanceof Uint8Array && t instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared");
      if (e.length !== t.length) throw new TypeError("Only instances of identical length can be compared");

      for (var r = 0, a = 1, _ = e.length; _-- > 0;) {
        r |= t[_] - e[_] >> 8 & a, a &= (t[_] ^ e[_]) - 1 >> 8;
      }

      return r + r + a - 1;
    }, e.from_base64 = function (e, t) {
      t = o(t);
      var a,
          _ = [],
          n = new u(3 * (e = k(_, e, "input")).length / 4),
          s = v(e),
          c = d(4),
          h = d(4);
      return _.push(s), _.push(n.address), _.push(n.result_bin_len_p), _.push(n.b64_end_p), 0 !== r._sodium_base642bin(n.address, n.length, s, e.length, 0, c, h, t) && b(_, "invalid input"), r.getValue(h, "i32") - s !== e.length && b(_, "incomplete input"), n.length = r.getValue(c, "i32"), a = n.to_Uint8Array(), g(_), a;
    }, e.from_hex = function (e) {
      var t,
          a = [],
          _ = new u((e = k(a, e, "input")).length / 2),
          n = v(e),
          s = d(4);

      return a.push(n), a.push(_.address), a.push(_.hex_end_p), 0 !== r._sodium_hex2bin(_.address, _.length, n, e.length, 0, 0, s) && b(a, "invalid input"), r.getValue(s, "i32") - n !== e.length && b(a, "incomplete input"), t = _.to_Uint8Array(), g(a), t;
    }, e.from_string = n, e.increment = function (e) {
      if (!(e instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be incremented");

      for (var t = 256, r = 0, a = e.length; r < a; r++) {
        t >>= 8, t += e[r], e[r] = 255 & t;
      }
    }, e.is_zero = function (e) {
      if (!(e instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be checked");

      for (var t = 0, r = 0, a = e.length; r < a; r++) {
        t |= e[r];
      }

      return 0 === t;
    }, e.libsodium = t, e.memcmp = function (e, t) {
      if (!(e instanceof Uint8Array && t instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be compared");
      if (e.length !== t.length) throw new TypeError("Only instances of identical length can be compared");

      for (var r = 0, a = 0, _ = e.length; a < _; a++) {
        r |= e[a] ^ t[a];
      }

      return 0 === r;
    }, e.memzero = function (e) {
      if (!(e instanceof Uint8Array)) throw new TypeError("Only Uint8Array instances can be wiped");

      for (var t = 0, r = e.length; t < r; t++) {
        e[t] = 0;
      }
    }, e.output_formats = function () {
      return ["uint8array", "text", "hex", "base64"];
    }, e.pad = function (e, t) {
      if (!(e instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array");
      if ((t |= 0) <= 0) throw new Error("block size must be > 0");
      var a,
          _ = [],
          n = d(4),
          s = 1,
          c = 0,
          h = 0 | e.length,
          o = new u(h + t);
      _.push(n), _.push(o.address);

      for (var p = o.address, y = o.address + h + t; p < y; p++) {
        r.HEAPU8[p] = e[c], c += s = 1 & ~((65535 & ((h -= s) >>> 48 | h >>> 32 | h >>> 16 | h)) - 1 >> 16);
      }

      return 0 !== r._sodium_pad(n, o.address, e.length, t, o.length) && b(_, "internal error"), o.length = r.getValue(n, "i32"), a = o.to_Uint8Array(), g(_), a;
    }, e.unpad = function (e, t) {
      if (!(e instanceof Uint8Array)) throw new TypeError("buffer must be a Uint8Array");
      if ((t |= 0) <= 0) throw new Error("block size must be > 0");

      var a = [],
          _ = v(e),
          n = d(4);

      return a.push(_), a.push(n), 0 !== r._sodium_unpad(n, _, e.length, t) && b(a, "unsupported/invalid padding"), e = (e = new Uint8Array(e)).subarray(0, r.getValue(n, "i32")), g(a), e;
    }, e.ready = _, e.symbols = function () {
      return Object.keys(e).sort();
    }, e.to_base64 = p, e.to_hex = c, e.to_string = s, e;
  }

  var r = "object" == _typeof(e.sodium) && "function" == typeof e.sodium.onload ? e.sodium.onload : null;
   true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports, __webpack_require__(/*! libsodium */ "./node_modules/libsodium/dist/modules/libsodium.js")], __WEBPACK_AMD_DEFINE_FACTORY__ = (t),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : undefined, r && e.sodium.ready.then(function () {
    r(e.sodium);
  });
}(this);

/***/ }),

/***/ "./node_modules/libsodium/dist/modules/libsodium.js":
/*!**********************************************************!*\
  !*** ./node_modules/libsodium/dist/modules/libsodium.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global, process, __dirname, Buffer) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

!function (A) {
  function I(A) {
    "use strict";

    var I;
    void 0 === (I = A) && (I = {});
    var g = I;
    "object" != _typeof(g.sodium) && ("object" == (typeof global === "undefined" ? "undefined" : _typeof(global)) ? g = global : "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)) && (g = window)), "object" == _typeof(g.sodium) && "number" == typeof g.sodium.totalMemory && (I.TOTAL_MEMORY = g.sodium.totalMemory);
    var B = I;
    return I.ready = new Promise(function (A, I) {
      (C = B).onAbort = I, C.print = function (A) {}, C.printErr = function (A) {}, C.onRuntimeInitialized = function () {
        try {
          C._crypto_secretbox_keybytes(), A();
        } catch (A) {
          I(A);
        }
      }, C.useBackupModule = function () {
        var A,
            I = void 0 !== (I = {}) ? I : {},
            g = {};

        for (A in I) {
          I.hasOwnProperty(A) && (g[A] = I[A]);
        }

        var C,
            Q,
            E,
            i,
            e = [],
            o = !1;
        C = "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)), Q = "function" == typeof importScripts, E = "object" == (typeof process === "undefined" ? "undefined" : _typeof(process)) && "object" == _typeof(process.versions) && "string" == typeof process.versions.node, o = E && !C && !Q, i = !C && !o && !Q;
        var c,
            a,
            n,
            r,
            t,
            f = "";
        o ? (f = __dirname + "/", c = function c(A, I) {
          var g;
          return (g = iA(A)) || (r || (r = __webpack_require__(/*! fs */ 0)), t || (t = __webpack_require__(/*! path */ "./node_modules/path-browserify/index.js")), A = t.normalize(A), g = r.readFileSync(A)), I ? g : g.toString();
        }, n = function n(A) {
          var I = c(A, !0);
          return I.buffer || (I = new Uint8Array(I)), D(I.buffer), I;
        }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), e = process.argv.slice(2),  true && (module.exports = I), process.on("unhandledRejection", j), I.inspect = function () {
          return "[Emscripten Module object]";
        }) : i ? ("undefined" != typeof read && (c = function c(A) {
          var I = iA(A);
          return I ? QA(I) : read(A);
        }), n = function n(A) {
          var I;
          return (I = iA(A)) ? I : "function" == typeof readbuffer ? new Uint8Array(readbuffer(A)) : (D("object" == _typeof(I = read(A, "binary"))), I);
        }, "undefined" != typeof scriptArgs ? e = scriptArgs : void 0 !== arguments && (e = arguments), "undefined" != typeof print && ("undefined" == typeof console && (console = {}), console.log = print, console.warn = console.error = "undefined" != typeof printErr ? printErr : print)) : (C || Q) && (Q ? f = self.location.href : document.currentScript && (f = document.currentScript.src), f = 0 !== f.indexOf("blob:") ? f.substr(0, f.lastIndexOf("/") + 1) : "", c = function c(A) {
          try {
            var I = new XMLHttpRequest();
            return I.open("GET", A, !1), I.send(null), I.responseText;
          } catch (I) {
            var g = iA(A);
            if (g) return QA(g);
            throw I;
          }
        }, Q && (n = function n(A) {
          try {
            var I = new XMLHttpRequest();
            return I.open("GET", A, !1), I.responseType = "arraybuffer", I.send(null), new Uint8Array(I.response);
          } catch (I) {
            var g = iA(A);
            if (g) return g;
            throw I;
          }
        }), a = function a(A, I, g) {
          var B = new XMLHttpRequest();
          B.open("GET", A, !0), B.responseType = "arraybuffer", B.onload = function () {
            if (200 == B.status || 0 == B.status && B.response) I(B.response);else {
              var C = iA(A);
              C ? I(C.buffer) : g();
            }
          }, B.onerror = g, B.send(null);
        });
        var w = I.print || void 0,
            y = I.printErr || void 0;

        for (A in g) {
          g.hasOwnProperty(A) && (I[A] = g[A]);
        }

        g = null, I.arguments && (e = I.arguments), I.thisProgram && I.thisProgram, I.quit && I.quit, new Array(8);
        var s = 0;
        I.wasmBinary && I.wasmBinary, I.noExitRuntime && I.noExitRuntime;
        var h = !1;

        function D(A, I) {
          A || j("Assertion failed: " + I);
        }

        var F,
            p,
            u,
            H,
            k,
            l,
            _,
            G = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0;

        function _d(A, I) {
          return A ? function (A, I, g) {
            for (var B = I + g, C = I; A[C] && !(C >= B);) {
              ++C;
            }

            if (C - I > 16 && A.subarray && G) return G.decode(A.subarray(I, C));

            for (var Q = ""; I < C;) {
              var E = A[I++];

              if (128 & E) {
                var i = 63 & A[I++];

                if (192 != (224 & E)) {
                  var e = 63 & A[I++];
                  if ((E = 224 == (240 & E) ? (15 & E) << 12 | i << 6 | e : (7 & E) << 18 | i << 12 | e << 6 | 63 & A[I++]) < 65536) Q += String.fromCharCode(E);else {
                    var o = E - 65536;
                    Q += String.fromCharCode(55296 | o >> 10, 56320 | 1023 & o);
                  }
                } else Q += String.fromCharCode((31 & E) << 6 | i);
              } else Q += String.fromCharCode(E);
            }

            return Q;
          }(u, A, I) : "";
        }

        function Y(A, I) {
          return A % I > 0 && (A += I - A % I), A;
        }

        function M(A) {
          F = A, I.HEAP8 = p = new Int8Array(A), I.HEAP16 = H = new Int16Array(A), I.HEAP32 = k = new Int32Array(A), I.HEAPU8 = u = new Uint8Array(A), I.HEAPU16 = new Uint16Array(A), I.HEAPU32 = new Uint32Array(A), I.HEAPF32 = l = new Float32Array(A), I.HEAPF64 = _ = new Float64Array(A);
        }

        "undefined" != typeof TextDecoder && new TextDecoder("utf-16le");
        var S = I.TOTAL_MEMORY || 16777216;

        function U(A) {
          for (; A.length > 0;) {
            var g = A.shift();

            if ("function" != typeof g) {
              var B = g.func;
              "number" == typeof B ? void 0 === g.arg ? I.dynCall_v(B) : I.dynCall_vi(B, g.arg) : B(void 0 === g.arg ? null : g.arg);
            } else g();
          }
        }

        S = (F = I.buffer ? I.buffer : new ArrayBuffer(S)).byteLength, M(F), k[8808] = 5278304;
        var v = [],
            b = [],
            J = [],
            P = [],
            R = Math.abs,
            N = Math.ceil,
            m = Math.floor,
            L = Math.min,
            x = 0,
            K = null,
            X = null;

        function j(A) {
          throw I.onAbort && I.onAbort(A), w(A += ""), y(A), h = !0, "abort(" + A + "). Build with -s ASSERTIONS=1 for more info.";
        }

        I.preloadedImages = {}, I.preloadedAudios = {};
        var T,
            q,
            V = null,
            z = "data:application/octet-stream;base64,";

        function W(A) {
          return String.prototype.startsWith ? A.startsWith(z) : 0 === A.indexOf(z);
        }

        var O = [function () {
          return I.getRandomValue();
        }, function () {
          if (void 0 === I.getRandomValue) try {
            var A = "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)) ? window : self,
                g = void 0 !== A.crypto ? A.crypto : A.msCrypto,
                B = function B() {
              var A = new Uint32Array(1);
              return g.getRandomValues(A), A[0] >>> 0;
            };

            B(), I.getRandomValue = B;
          } catch (A) {
            try {
              var C = __webpack_require__(/*! crypto */ "./node_modules/crypto-browserify/index.js"),
                  Q = function Q() {
                var A = C.randomBytes(4);
                return (A[0] << 24 | A[1] << 16 | A[2] << 8 | A[3]) >>> 0;
              };

              Q(), I.getRandomValue = Q;
            } catch (A) {
              throw "No secure random number generator found";
            }
          }
        }];

        function Z(A) {
          return A;
        }

        function $(A) {
          return A.replace(/\b__Z[\w\d_]+/g, function (A) {
            var I = Z(A);
            return A === I ? A : I + " [" + A + "]";
          });
        }

        function AA() {
          var A = new Error();

          if (!A.stack) {
            try {
              throw new Error(0);
            } catch (I) {
              A = I;
            }

            if (!A.stack) return "(no stack trace available)";
          }

          return A.stack.toString();
        }

        function IA() {
          return p.length;
        }

        function gA(A) {
          try {
            var I = new ArrayBuffer(A);
            if (I.byteLength != A) return;
            return new Int8Array(I).set(p), aA(I), M(I), 1;
          } catch (A) {}
        }

        function BA(A) {
          return I.___errno_location && (k[I.___errno_location() >> 2] = A), A;
        }

        V = "data:application/octet-stream;base64, ";
        var CA = !1;

        function QA(A) {
          for (var I = [], g = 0; g < A.length; g++) {
            var B = A[g];
            B > 255 && (CA && D(!1, "Character code " + B + " (" + String.fromCharCode(B) + ")  at offset " + g + " not in 0x00-0xFF."), B &= 255), I.push(String.fromCharCode(B));
          }

          return I.join("");
        }

        var EA = "function" == typeof atob ? atob : function (A) {
          var I,
              g,
              B,
              C,
              Q,
              E,
              i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
              e = "",
              o = 0;
          A = A.replace(/[^A-Za-z0-9\+\/\=]/g, "");

          do {
            I = i.indexOf(A.charAt(o++)) << 2 | (C = i.indexOf(A.charAt(o++))) >> 4, g = (15 & C) << 4 | (Q = i.indexOf(A.charAt(o++))) >> 2, B = (3 & Q) << 6 | (E = i.indexOf(A.charAt(o++))), e += String.fromCharCode(I), 64 !== Q && (e += String.fromCharCode(g)), 64 !== E && (e += String.fromCharCode(B));
          } while (o < A.length);

          return e;
        };

        function iA(A) {
          if (W(A)) return function (A) {
            if ("boolean" == typeof o && o) {
              var I;

              try {
                I = Buffer.from(A, "base64");
              } catch (g) {
                I = new Buffer(A, "base64");
              }

              return new Uint8Array(I.buffer, I.byteOffset, I.byteLength);
            }

            try {
              for (var g = EA(A), B = new Uint8Array(g.length), C = 0; C < g.length; ++C) {
                B[C] = g.charCodeAt(C);
              }

              return B;
            } catch (A) {
              throw new Error("Converting base64 string to bytes failed.");
            }
          }(A.slice(z.length));
        }

        var eA,
            oA,
            cA = function (A, I, g) {
          "almost asm";

          var B = new A.Int8Array(g),
              C = new A.Int32Array(g),
              Q = new A.Uint8Array(g),
              E = A.Math.imul,
              i = A.Math.clz32,
              e = I.b,
              o = I.c,
              c = I.d,
              a = I.f,
              n = I.g,
              r = I.h,
              t = I.i,
              f = I.j,
              w = I.k,
              y = 35424;

          function s(A, I) {
            A |= 0, I |= 0;
            var g,
                E,
                i,
                e,
                c,
                a,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0,
                m = 0,
                L = 0,
                x = 0,
                K = 0,
                X = 0,
                j = 0,
                T = 0,
                q = 0,
                V = 0,
                z = 0,
                W = 0,
                O = 0,
                Z = 0,
                $ = 0,
                AA = 0,
                IA = 0,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0,
                tA = 0,
                fA = 0,
                wA = 0,
                yA = 0,
                sA = 0;
            g = y, E = y = y + 63 & -64, y = y + 256 | 0, n = 0;

            do {
              f = 0 | qI(I + (n << 3) | 0), t = 0 | o(), C[(r = E + 128 + (n << 3) | 0) >> 2] = f, C[r + 4 >> 2] = t, n = n + 1 | 0;
            } while (16 != (0 | n));

            n = A, r = (I = E) + 64 | 0;

            do {
              B[I >> 0] = 0 | B[n >> 0], I = I + 1 | 0, n = n + 1 | 0;
            } while ((0 | I) < (0 | r));

            for (C[E + 88 >> 2] = 1595750129, C[E + 88 + 4 >> 2] = -1521486534, X = -1377402159 ^ (Q[A + 64 >> 0] | Q[A + 64 + 1 >> 0] << 8 | Q[A + 64 + 2 >> 0] << 16 | Q[A + 64 + 3 >> 0] << 24), K = 1359893119 ^ (Q[A + 64 + 4 >> 0] | Q[A + 64 + 4 + 1 >> 0] << 8 | Q[A + 64 + 4 + 2 >> 0] << 16 | Q[A + 64 + 4 + 3 >> 0] << 24), S = 725511199 ^ (Q[A + 72 >> 0] | Q[A + 72 + 1 >> 0] << 8 | Q[A + 72 + 2 >> 0] << 16 | Q[A + 72 + 3 >> 0] << 24), U = -1694144372 ^ (Q[A + 72 + 4 >> 0] | Q[A + 72 + 4 + 1 >> 0] << 8 | Q[A + 72 + 4 + 2 >> 0] << 16 | Q[A + 72 + 4 + 3 >> 0] << 24), u = -79577749 ^ (Q[A + 80 >> 0] | Q[A + 80 + 1 >> 0] << 8 | Q[A + 80 + 2 >> 0] << 16 | Q[A + 80 + 3 >> 0] << 24), H = 528734635 ^ (Q[A + 80 + 4 >> 0] | Q[A + 80 + 4 + 1 >> 0] << 8 | Q[A + 80 + 4 + 2 >> 0] << 16 | Q[A + 80 + 4 + 3 >> 0] << 24), AA = 327033209 ^ (Q[A + 88 >> 0] | Q[A + 88 + 1 >> 0] << 8 | Q[A + 88 + 2 >> 0] << 16 | Q[A + 88 + 3 >> 0] << 24), $ = 1541459225 ^ (Q[A + 88 + 4 >> 0] | Q[A + 88 + 4 + 1 >> 0] << 8 | Q[A + 88 + 4 + 2 >> 0] << 16 | Q[A + 88 + 4 + 3 >> 0] << 24), h = 0 | C[E + 32 >> 2], D = 0 | C[E + 32 + 4 >> 2], D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (yA = 0 | vg(0 | (j = 0 | C[E + 128 >> 2]), 0 | (T = 0 | C[E + 128 + 4 >> 2]), 0 | h, 0 | D)), 0 | (wA = 0 | o()), 0 | C[E >> 2], 0 | C[E + 4 >> 2])) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), -205731576, 1779033703)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), IA = 0 | C[E + 128 + 8 >> 2], gA = 0 | C[E + 128 + 8 + 4 >> 2], X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | D, 0 | h, 0 | wA, 0 | yA)), 0 | o(), 0 | IA, 0 | gA)) ^ K, (wA = 0 | o()) ^ X, 16), K = 0 | o(), C[E + 96 >> 2] = X, C[E + 96 + 4 >> 2] = K, f = 0 | vg(0 | X, 0 | K, 0 | I, 0 | f), I = 0 | o(), C[E + 64 >> 2] = f, C[E + 64 + 4 >> 2] = I, h = 0 | ZI(f ^ D, I ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, W = 0 | C[E + 40 >> 2], O = 0 | C[E + 40 + 4 >> 2], O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI((nA = 0 | vg(0 | (aA = 0 | vg(0 | (r = 0 | C[E + 128 + 16 >> 2]), 0 | (n = 0 | C[E + 128 + 16 + 4 >> 2]), 0 | W, 0 | O)), 0 | (nA = 0 | o()), 0 | C[E + 8 >> 2], 0 | C[E + 8 + 4 >> 2])) ^ S, (aA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), -2067093701, -1150833019)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), p = 0 | C[E + 128 + 24 >> 2], k = 0 | C[E + 128 + 24 + 4 >> 2], S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | O, 0 | W, 0 | nA, 0 | aA)), 0 | o(), 0 | p, 0 | k)) ^ U, (nA = 0 | o()) ^ S, 16), U = 0 | o(), C[E + 104 >> 2] = S, C[E + 104 + 4 >> 2] = U, F = 0 | vg(0 | S, 0 | U, 0 | s, 0 | F), s = 0 | o(), C[E + 72 >> 2] = F, C[E + 72 + 4 >> 2] = s, W = 0 | ZI(F ^ O, s ^ W, 63), O = 0 | o(), m = 0 | C[E + 48 >> 2], L = 0 | C[E + 48 + 4 >> 2], L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI((oA = 0 | vg(0 | (eA = 0 | vg(0 | (a = 0 | C[E + 128 + 32 >> 2]), 0 | (rA = 0 | C[E + 128 + 32 + 4 >> 2]), 0 | m, 0 | L)), 0 | (oA = 0 | o()), 0 | C[E + 16 >> 2], 0 | C[E + 16 + 4 >> 2])) ^ u, (eA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), -23791573, 1013904242)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), i = 0 | C[E + 128 + 40 >> 2], G = 0 | C[E + 128 + 40 + 4 >> 2], m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | L, 0 | m, 0 | oA, 0 | eA)), 0 | o(), 0 | i, 0 | G)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), Y = 0 | C[E + 56 >> 2], d = 0 | C[E + 56 + 4 >> 2], d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (QA = 0 | vg(0 | (_ = 0 | C[E + 128 + 48 >> 2]), 0 | (l = 0 | C[E + 128 + 48 + 4 >> 2]), 0 | Y, 0 | d)), 0 | (EA = 0 | o()), 0 | C[E + 24 >> 2], 0 | C[E + 24 + 4 >> 2])) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 1595750129, -1521486534)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), M = 0 | C[E + 128 + 56 >> 2], v = 0 | C[E + 128 + 56 + 4 >> 2], Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | d, 0 | Y, 0 | EA, 0 | QA)), 0 | o(), 0 | M, 0 | v)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), q = 0 | C[E + 128 + 64 >> 2], V = 0 | C[E + 128 + 64 + 4 >> 2], O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | W, 0 | O, 0 | yA, 0 | wA)), 0 | o(), 0 | q, 0 | V)) ^ AA, (yA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), c = 0 | C[E + 128 + 72 >> 2], cA = 0 | C[E + 128 + 72 + 4 >> 2], AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | O, 0 | W, 0 | wA, 0 | yA)), 0 | o(), 0 | c, 0 | cA)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z), z = 0 | o(), C[E + 80 >> 2] = Z, C[E + 80 + 4 >> 2] = z, W = 0 | ZI(Z ^ O, z ^ W, 63), O = 0 | o(), BA = 0 | C[E + 128 + 80 >> 2], CA = 0 | C[E + 128 + 80 + 4 >> 2], L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | m, 0 | L, 0 | aA, 0 | nA)), 0 | o(), 0 | BA, 0 | CA)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), b = 0 | C[E + 128 + 88 >> 2], J = 0 | C[E + 128 + 88 + 4 >> 2], m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | L, 0 | m, 0 | nA, 0 | aA)), 0 | o(), 0 | b, 0 | J)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), t = 0 | C[E + 128 + 96 >> 2], w = 0 | C[E + 128 + 96 + 4 >> 2], d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | Y, 0 | d, 0 | eA, 0 | oA)), 0 | o(), 0 | t, 0 | w)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), e = 0 | C[E + 128 + 104 >> 2], iA = 0 | C[E + 128 + 104 + 4 >> 2], Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | d, 0 | Y, 0 | oA, 0 | eA)), 0 | o(), 0 | e, 0 | iA)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), tA = 0 | C[E + 128 + 112 >> 2], fA = 0 | C[E + 128 + 112 + 4 >> 2], D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (EA = 0 | vg(0 | QA, 0 | EA, 0 | h, 0 | D)), 0 | o(), 0 | tA, 0 | fA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), P = 0 | C[E + 128 + 120 >> 2], R = 0 | C[E + 128 + 120 + 4 >> 2], h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | D, 0 | h, 0 | EA, 0 | QA)), 0 | o(), 0 | P, 0 | R)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | tA, 0 | fA, 0 | yA, 0 | wA)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | BA, 0 | CA)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | a, 0 | rA)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | q, 0 | V)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | c, 0 | cA)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | P, 0 | R, 0 | oA, 0 | eA)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | e, 0 | iA)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | _, 0 | l)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | IA, 0 | gA)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | t, 0 | w)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | j, 0 | T)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | r, 0 | n)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | b, 0 | J)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | M, 0 | v)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | i, 0 | G)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | p, 0 | k)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | b, 0 | J)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | q, 0 | V)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | t, 0 | w)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | j, 0 | T)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | i, 0 | G)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | r, 0 | n)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | P, 0 | R)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | e, 0 | iA)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | BA, 0 | CA)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | tA, 0 | fA)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | p, 0 | k)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | _, 0 | l)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | M, 0 | v)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | IA, 0 | gA)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | c, 0 | cA)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | a, 0 | rA)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | M, 0 | v)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | c, 0 | cA)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | p, 0 | k)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | IA, 0 | gA)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | e, 0 | iA)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | t, 0 | w)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | b, 0 | J)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | tA, 0 | fA)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | r, 0 | n)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | _, 0 | l)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | i, 0 | G)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | BA, 0 | CA)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | a, 0 | rA)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | j, 0 | T)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | P, 0 | R)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | q, 0 | V)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | c, 0 | cA)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | j, 0 | T)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | i, 0 | G)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | M, 0 | v)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | r, 0 | n)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | a, 0 | rA)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | BA, 0 | CA)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | P, 0 | R)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | tA, 0 | fA)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | IA, 0 | gA)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | b, 0 | J)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | t, 0 | w)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | _, 0 | l)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | q, 0 | V)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | p, 0 | k)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | e, 0 | iA)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | r, 0 | n)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | t, 0 | w)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | _, 0 | l)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | BA, 0 | CA)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | j, 0 | T)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | b, 0 | J)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | q, 0 | V)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | p, 0 | k)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | a, 0 | rA)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | e, 0 | iA)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | M, 0 | v)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | i, 0 | G)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | P, 0 | R)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | tA, 0 | fA)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | IA, 0 | gA)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | c, 0 | cA)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | t, 0 | w)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | i, 0 | G)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | IA, 0 | gA)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | P, 0 | R)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | tA, 0 | fA)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | e, 0 | iA)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | a, 0 | rA)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | BA, 0 | CA)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | j, 0 | T)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | M, 0 | v)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | _, 0 | l)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | p, 0 | k)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | c, 0 | cA)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | r, 0 | n)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | q, 0 | V)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | b, 0 | J)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | e, 0 | iA)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | b, 0 | J)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | M, 0 | v)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | tA, 0 | fA)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | t, 0 | w)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | IA, 0 | gA)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | p, 0 | k)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | c, 0 | cA)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | i, 0 | G)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | j, 0 | T)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | P, 0 | R)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | a, 0 | rA)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | q, 0 | V)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | _, 0 | l)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | r, 0 | n)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | BA, 0 | CA)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | _, 0 | l)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | P, 0 | R)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | tA, 0 | fA)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | c, 0 | cA)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | b, 0 | J)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | p, 0 | k)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | j, 0 | T)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | q, 0 | V)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | t, 0 | w)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | r, 0 | n)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | e, 0 | iA)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | M, 0 | v)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | IA, 0 | gA)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | a, 0 | rA)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | BA, 0 | CA)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | i, 0 | G)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | BA, 0 | CA)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | r, 0 | n)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | q, 0 | V)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | a, 0 | rA)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | M, 0 | v)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | _, 0 | l)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | IA, 0 | gA)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | i, 0 | G)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | P, 0 | R)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | b, 0 | J)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | c, 0 | cA)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | tA, 0 | fA)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | p, 0 | k)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | t, 0 | w)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | e, 0 | iA)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | j, 0 | T)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | j, 0 | T)), 0 | o(), 0 | h, 0 | D)) ^ X, (yA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | IA, 0 | gA)), 0 | o(), 0 | D, 0 | h)) ^ K, (wA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (sA = 0 | vg(0 | W, 0 | O, 0 | r, 0 | n)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | p, 0 | k)), 0 | o(), 0 | O, 0 | W)) ^ U, (nA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (sA = 0 | vg(0 | m, 0 | L, 0 | a, 0 | rA)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | i, 0 | G)), 0 | o(), 0 | L, 0 | m)) ^ H, (oA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | Y, 0 | d, 0 | _, 0 | l)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | M, 0 | v)), 0 | o(), 0 | d, 0 | Y)) ^ $, (EA = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (wA = 0 | vg(0 | (wA = 0 | vg(0 | yA, 0 | wA, 0 | q, 0 | V)), 0 | o(), 0 | W, 0 | O)), $ ^ (yA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), AA = 0 | ZI((yA = 0 | vg(0 | (yA = 0 | vg(0 | wA, 0 | yA, 0 | c, 0 | cA)), 0 | o(), 0 | O, 0 | W)) ^ $, (wA = 0 | o()) ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, W = 0 | ZI((Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z)) ^ O, (z = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((nA = 0 | vg(0 | (nA = 0 | vg(0 | aA, 0 | nA, 0 | BA, 0 | CA)), 0 | o(), 0 | m, 0 | L)) ^ X, (aA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((x = 0 | vg(0 | (X = 0 | ZI((aA = 0 | vg(0 | (aA = 0 | vg(0 | nA, 0 | aA, 0 | b, 0 | J)), 0 | o(), 0 | L, 0 | m)) ^ K, (nA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | N, 0 | x)) ^ L, (N = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((oA = 0 | vg(0 | (oA = 0 | vg(0 | eA, 0 | oA, 0 | t, 0 | w)), 0 | o(), 0 | Y, 0 | d)) ^ S, (eA = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((f = 0 | vg(0 | (S = 0 | ZI((eA = 0 | vg(0 | (eA = 0 | vg(0 | oA, 0 | eA, 0 | e, 0 | iA)), 0 | o(), 0 | d, 0 | Y)) ^ U, (oA = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | I, 0 | f)) ^ d, (I = 0 | o()) ^ Y, 63), d = 0 | o(), D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((EA = 0 | vg(0 | (sA = 0 | vg(0 | h, 0 | D, 0 | tA, 0 | fA)), 0 | o(), 0 | QA, 0 | EA)) ^ u, (QA = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((F = 0 | vg(0 | (u = 0 | ZI((QA = 0 | vg(0 | (QA = 0 | vg(0 | EA, 0 | QA, 0 | P, 0 | R)), 0 | o(), 0 | D, 0 | h)) ^ H, (EA = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | s, 0 | F)) ^ D, (s = 0 | o()) ^ h, 63), D = 0 | o(), D = 0 | ZI((I = 0 | vg(0 | (K = 0 | ZI((fA = 0 | vg(0 | (fA = 0 | vg(0 | yA, 0 | wA, 0 | tA, 0 | fA)), 0 | o(), 0 | h, 0 | D)) ^ X, (tA = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | f, 0 | I)) ^ h, (f = 0 | o()) ^ D, 24), h = 0 | o(), h = 0 | ZI((f = 0 | vg(0 | (X = 0 | ZI((CA = 0 | vg(0 | (CA = 0 | vg(0 | fA, 0 | tA, 0 | BA, 0 | CA)), 0 | o(), 0 | D, 0 | h)) ^ K, (BA = 0 | o()) ^ X, 16)), 0 | (K = 0 | o()), 0 | I, 0 | f)) ^ D, (I = 0 | o()) ^ h, 63), D = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = D, O = 0 | ZI((s = 0 | vg(0 | (U = 0 | ZI(S ^ (nA = 0 | vg(0 | (rA = 0 | vg(0 | W, 0 | O, 0 | a, 0 | rA)), 0 | o(), 0 | aA, 0 | nA)), U ^ (aA = 0 | o()), 32)), 0 | (S = 0 | o()), 0 | F, 0 | s)) ^ W, (F = 0 | o()) ^ O, 24), W = 0 | o(), W = 0 | ZI((F = 0 | vg(0 | (S = 0 | ZI((V = 0 | vg(0 | (V = 0 | vg(0 | nA, 0 | aA, 0 | q, 0 | V)), 0 | o(), 0 | O, 0 | W)) ^ U, (q = 0 | o()) ^ S, 16)), 0 | (U = 0 | o()), 0 | s, 0 | F)) ^ O, (s = 0 | o()) ^ W, 63), O = 0 | o(), L = 0 | ZI((z = 0 | vg(0 | (H = 0 | ZI(u ^ (oA = 0 | vg(0 | (cA = 0 | vg(0 | m, 0 | L, 0 | c, 0 | cA)), 0 | o(), 0 | eA, 0 | oA)), H ^ (eA = 0 | o()), 32)), 0 | (u = 0 | o()), 0 | Z, 0 | z)) ^ m, (Z = 0 | o()) ^ L, 24), m = 0 | o(), m = 0 | ZI((Z = 0 | vg(0 | (u = 0 | ZI((R = 0 | vg(0 | (R = 0 | vg(0 | oA, 0 | eA, 0 | P, 0 | R)), 0 | o(), 0 | L, 0 | m)) ^ H, (P = 0 | o()) ^ u, 16)), 0 | (H = 0 | o()), 0 | z, 0 | Z)) ^ L, (z = 0 | o()) ^ m, 63), L = 0 | o(), d = 0 | ZI((N = 0 | vg(0 | ($ = 0 | ZI((EA = 0 | vg(0 | (iA = 0 | vg(0 | Y, 0 | d, 0 | e, 0 | iA)), 0 | o(), 0 | QA, 0 | EA)) ^ AA, (QA = 0 | o()) ^ $, 32)), 0 | (AA = 0 | o()), 0 | x, 0 | N)) ^ Y, (x = 0 | o()) ^ d, 24), Y = 0 | o(), Y = 0 | ZI((x = 0 | vg(0 | (AA = 0 | ZI((l = 0 | vg(0 | (l = 0 | vg(0 | EA, 0 | QA, 0 | _, 0 | l)), 0 | o(), 0 | d, 0 | Y)) ^ $, (_ = 0 | o()) ^ AA, 16)), 0 | ($ = 0 | o()), 0 | N, 0 | x)) ^ d, (N = 0 | o()) ^ Y, 63), d = 0 | o(), O = 0 | ZI((z = 0 | vg(0 | ($ = 0 | ZI(AA ^ (gA = 0 | vg(0 | (gA = 0 | vg(0 | CA, 0 | BA, 0 | IA, 0 | gA)), 0 | o(), 0 | W, 0 | O)), $ ^ (IA = 0 | o()), 32)), 0 | (AA = 0 | o()), 0 | Z, 0 | z)) ^ W, (Z = 0 | o()) ^ O, 24), W = 0 | o(), w = 0 | vg(0 | (w = 0 | vg(0 | gA, 0 | IA, 0 | t, 0 | w)), 0 | o(), 0 | O, 0 | W), t = 0 | o(), C[E >> 2] = w, C[E + 4 >> 2] = t, AA = 0 | ZI(w ^ $, t ^ AA, 16), $ = 0 | o(), C[E + 120 >> 2] = AA, C[E + 120 + 4 >> 2] = $, Z = 0 | vg(0 | AA, 0 | $, 0 | z, 0 | Z), z = 0 | o(), C[E + 80 >> 2] = Z, C[E + 80 + 4 >> 2] = z, W = 0 | ZI(Z ^ O, z ^ W, 63), z = 0 | o(), C[E + 40 >> 2] = W, C[E + 40 + 4 >> 2] = z, L = 0 | ZI((N = 0 | vg(0 | (K = 0 | ZI((T = 0 | vg(0 | (T = 0 | vg(0 | V, 0 | q, 0 | j, 0 | T)), 0 | o(), 0 | m, 0 | L)) ^ X, (j = 0 | o()) ^ K, 32)), 0 | (X = 0 | o()), 0 | x, 0 | N)) ^ m, (x = 0 | o()) ^ L, 24), m = 0 | o(), n = 0 | vg(0 | (n = 0 | vg(0 | T, 0 | j, 0 | r, 0 | n)), 0 | o(), 0 | L, 0 | m), r = 0 | o(), C[E + 8 >> 2] = n, C[E + 8 + 4 >> 2] = r, X = 0 | ZI(n ^ K, r ^ X, 16), K = 0 | o(), C[E + 96 >> 2] = X, C[E + 96 + 4 >> 2] = K, x = 0 | vg(0 | X, 0 | K, 0 | N, 0 | x), N = 0 | o(), C[E + 88 >> 2] = x, C[E + 88 + 4 >> 2] = N, m = 0 | ZI(x ^ L, N ^ m, 63), N = 0 | o(), C[E + 48 >> 2] = m, C[E + 48 + 4 >> 2] = N, d = 0 | ZI((I = 0 | vg(0 | (U = 0 | ZI((J = 0 | vg(0 | (J = 0 | vg(0 | R, 0 | P, 0 | b, 0 | J)), 0 | o(), 0 | Y, 0 | d)) ^ S, (b = 0 | o()) ^ U, 32)), 0 | (S = 0 | o()), 0 | f, 0 | I)) ^ Y, (f = 0 | o()) ^ d, 24), Y = 0 | o(), v = 0 | vg(0 | (v = 0 | vg(0 | J, 0 | b, 0 | M, 0 | v)), 0 | o(), 0 | d, 0 | Y), M = 0 | o(), C[E + 16 >> 2] = v, C[E + 16 + 4 >> 2] = M, S = 0 | ZI(v ^ U, M ^ S, 16), M = 0 | o(), C[E + 104 >> 2] = S, C[E + 104 + 4 >> 2] = M, f = 0 | vg(0 | S, 0 | M, 0 | I, 0 | f), I = 0 | o(), C[E + 64 >> 2] = f, C[E + 64 + 4 >> 2] = I, Y = 0 | ZI(f ^ d, I ^ Y, 63), d = 0 | o(), C[E + 56 >> 2] = Y, C[E + 56 + 4 >> 2] = d, D = 0 | ZI((s = 0 | vg(0 | (H = 0 | ZI((_ = 0 | vg(0 | (G = 0 | vg(0 | h, 0 | D, 0 | i, 0 | G)), 0 | o(), 0 | l, 0 | _)) ^ u, (l = 0 | o()) ^ H, 32)), 0 | (u = 0 | o()), 0 | F, 0 | s)) ^ h, (F = 0 | o()) ^ D, 24), h = 0 | o(), k = 0 | vg(0 | (k = 0 | vg(0 | _, 0 | l, 0 | p, 0 | k)), 0 | o(), 0 | D, 0 | h), p = 0 | o(), C[E + 24 >> 2] = k, C[E + 24 + 4 >> 2] = p, u = 0 | ZI(k ^ H, p ^ u, 16), p = 0 | o(), C[E + 112 >> 2] = u, C[E + 112 + 4 >> 2] = p, F = 0 | vg(0 | u, 0 | p, 0 | s, 0 | F), s = 0 | o(), C[E + 72 >> 2] = F, C[E + 72 + 4 >> 2] = s, h = 0 | ZI(F ^ D, s ^ h, 63), s = 0 | o(), C[E + 32 >> 2] = h, C[E + 32 + 4 >> 2] = s, f = w ^ (Q[A >> 0] | Q[A + 1 >> 0] << 8 | Q[A + 2 >> 0] << 16 | Q[A + 3 >> 0] << 24) ^ f, I = t ^ (Q[A + 4 >> 0] | Q[A + 4 + 1 >> 0] << 8 | Q[A + 4 + 2 >> 0] << 16 | Q[A + 4 + 3 >> 0] << 24) ^ I, B[A >> 0] = f, B[A + 1 >> 0] = f >> 8, B[A + 2 >> 0] = f >> 16, B[A + 3 >> 0] = f >> 24, B[A + 4 >> 0] = I, B[A + 4 + 1 >> 0] = I >> 8, B[A + 4 + 2 >> 0] = I >> 16, B[A + 4 + 3 >> 0] = I >> 24, I = 1; yA = E + (I + 8 << 3) | 0, wA = n ^ (Q[(sA = A + (I << 3) | 0) >> 0] | Q[sA + 1 >> 0] << 8 | Q[sA + 2 >> 0] << 16 | Q[sA + 3 >> 0] << 24) ^ C[yA >> 2], yA = r ^ (Q[sA + 4 >> 0] | Q[sA + 4 + 1 >> 0] << 8 | Q[sA + 4 + 2 >> 0] << 16 | Q[sA + 4 + 3 >> 0] << 24) ^ C[yA + 4 >> 2], B[sA >> 0] = wA, B[sA + 1 >> 0] = wA >> 8, B[sA + 2 >> 0] = wA >> 16, B[sA + 3 >> 0] = wA >> 24, B[sA + 4 >> 0] = yA, B[sA + 4 + 1 >> 0] = yA >> 8, B[sA + 4 + 2 >> 0] = yA >> 16, B[sA + 4 + 3 >> 0] = yA >> 24, 8 != (0 | (I = I + 1 | 0));) {
              n = 0 | C[E + (I << 3) >> 2], r = 0 | C[E + (I << 3) + 4 >> 2];
            }

            y = g;
          }

          function h(A, I, g, C) {
            A |= 0, g |= 0, C |= 0;
            var Q,
                E,
                i,
                e,
                c,
                a,
                n,
                r,
                t,
                f,
                w,
                y,
                s,
                h,
                D,
                F,
                p,
                u,
                H,
                k,
                l,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0,
                m = 0,
                L = 0,
                x = 0,
                K = 0,
                X = 0,
                j = 0,
                T = 0,
                q = 0,
                V = 0,
                z = 0,
                W = 0,
                O = 0,
                Z = 0,
                $ = 0,
                AA = 0,
                IA = 0,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0,
                tA = 0,
                fA = 0,
                wA = 0,
                yA = 0,
                sA = 0,
                hA = 0,
                DA = 0,
                FA = 0,
                pA = 0,
                uA = 0,
                HA = 0,
                kA = 0,
                lA = 0,
                _A = 0,
                GA = 0,
                dA = 0,
                YA = 0,
                MA = 0,
                SA = 0,
                UA = 0,
                vA = 0,
                bA = 0,
                JA = 0,
                PA = 0,
                RA = 0,
                NA = 0,
                mA = 0,
                LA = 0,
                xA = 0,
                KA = 0,
                XA = 0,
                jA = 0,
                TA = 0,
                qA = 0,
                VA = 0,
                zA = 0,
                WA = 0,
                OA = 0,
                ZA = 0,
                $A = 0,
                AI = 0,
                II = 0,
                gI = 0,
                BI = 0,
                CI = 0,
                QI = 0,
                EI = 0,
                iI = 0,
                eI = 0,
                oI = 0,
                cI = 0,
                aI = 0,
                nI = 0,
                rI = 0,
                tI = 0,
                fI = 0,
                wI = 0,
                yI = 0,
                sI = 0,
                hI = 0,
                DI = 0,
                FI = 0,
                pI = 0,
                uI = 0,
                HI = 0,
                lI = 0,
                _I = 0,
                GI = 0,
                dI = 0,
                YI = 0,
                MI = 0,
                SI = 0,
                UI = 0,
                vI = 0,
                bI = 0,
                JI = 0,
                PI = 0,
                RI = 0,
                NI = 0,
                mI = 0,
                LI = 0,
                xI = 0,
                KI = 0,
                XI = 0,
                jI = 0,
                TI = 0,
                qI = 0,
                VI = 0,
                zI = 0,
                WI = 0,
                OI = 0,
                ZI = 0,
                $I = 0,
                Ag = 0,
                Ig = 0,
                gg = 0,
                Cg = 0,
                Eg = 0,
                eg = 0,
                og = 0,
                cg = 0,
                ag = 0,
                ng = 0,
                tg = 0,
                fg = 0,
                wg = 0,
                sg = 0,
                hg = 0,
                Dg = 0,
                Fg = 0,
                pg = 0,
                ug = 0;
            wA = 0 | Bg(0 | B[(I |= 0) >> 0], 0 | B[I + 1 >> 0], 0 | B[I + 2 >> 0]), o(), UI = 0 | yg(0 | (UI = 0 | kI(I + 2 | 0)), 0 | o(), 5), o(), uI = 0 | yg(0 | (uI = 0 | Bg(0 | B[I + 5 >> 0], 0 | B[I + 6 >> 0], 0 | B[I + 7 >> 0])), 0 | o(), 2), o(), SI = 0 | yg(0 | (SI = 0 | kI(I + 7 | 0)), 0 | o(), 7), o(), yI = 0 | yg(0 | (yI = 0 | kI(I + 10 | 0)), 0 | o(), 4), o(), CA = 0 | yg(0 | (CA = 0 | Bg(0 | B[I + 13 >> 0], 0 | B[I + 14 >> 0], 0 | B[I + 15 >> 0])), 0 | o(), 1), o(), FA = 0 | yg(0 | (FA = 0 | kI(I + 15 | 0)), 0 | o(), 6), o(), _ = 0 | yg(0 | (_ = 0 | Bg(0 | B[I + 18 >> 0], 0 | B[I + 19 >> 0], 0 | B[I + 20 >> 0])), 0 | o(), 3), o(), QA = 0 | Bg(0 | B[I + 21 >> 0], 0 | B[I + 22 >> 0], 0 | B[I + 23 >> 0]), o(), q = 0 | yg(0 | (q = 0 | kI(I + 23 | 0)), 0 | o(), 5), o(), HA = 0 | yg(0 | (HA = 0 | Bg(0 | B[I + 26 >> 0], 0 | B[I + 27 >> 0], 0 | B[I + 28 >> 0])), 0 | o(), 2), o(), GA = 0 | yg(0 | (GA = 0 | kI(I + 28 | 0)), 0 | o(), 7), dA = 0 | o(), XI = 0 | Bg(0 | B[g >> 0], 0 | B[g + 1 >> 0], 0 | B[g + 2 >> 0]), o(), hI = 0 | yg(0 | (hI = 0 | kI(g + 2 | 0)), 0 | o(), 5), o(), gI = 0 | yg(0 | (gI = 0 | Bg(0 | B[g + 5 >> 0], 0 | B[g + 6 >> 0], 0 | B[g + 7 >> 0])), 0 | o(), 2), o(), G = 0 | yg(0 | (G = 0 | kI(g + 7 | 0)), 0 | o(), 7), o(), d = 0 | yg(0 | (d = 0 | kI(g + 10 | 0)), 0 | o(), 4), o(), x = 0 | yg(0 | (x = 0 | Bg(0 | B[g + 13 >> 0], 0 | B[g + 14 >> 0], 0 | B[g + 15 >> 0])), 0 | o(), 1), o(), zA = 0 | yg(0 | (zA = 0 | kI(g + 15 | 0)), 0 | o(), 6), o(), sA = 0 | yg(0 | (sA = 0 | Bg(0 | B[g + 18 >> 0], 0 | B[g + 19 >> 0], 0 | B[g + 20 >> 0])), 0 | o(), 3), o(), RA = 0 | Bg(0 | B[g + 21 >> 0], 0 | B[g + 22 >> 0], 0 | B[g + 23 >> 0]), o(), IA = 0 | yg(0 | (IA = 0 | kI(g + 23 | 0)), 0 | o(), 5), o(), NI = 0 | yg(0 | (NI = 0 | Bg(0 | B[g + 26 >> 0], 0 | B[g + 27 >> 0], 0 | B[g + 28 >> 0])), 0 | o(), 2), o(), rA = 0 | yg(0 | (rA = 0 | kI(g + 28 | 0)), 0 | o(), 7), nA = 0 | o(), LA = 0 | Bg(0 | B[C >> 0], 0 | B[C + 1 >> 0], 0 | B[C + 2 >> 0]), o(), BA = 0 | yg(0 | (BA = 0 | kI(C + 2 | 0)), 0 | o(), 5), o(), KA = 0 | yg(0 | (KA = 0 | Bg(0 | B[C + 5 >> 0], 0 | B[C + 6 >> 0], 0 | B[C + 7 >> 0])), 0 | o(), 2), o(), bA = 0 | yg(0 | (bA = 0 | kI(C + 7 | 0)), 0 | o(), 7), o(), PA = 0 | yg(0 | (PA = 0 | kI(C + 10 | 0)), 0 | o(), 4), o(), WA = 0 | yg(0 | (WA = 0 | Bg(0 | B[C + 13 >> 0], 0 | B[C + 14 >> 0], 0 | B[C + 15 >> 0])), 0 | o(), 1), o(), _I = 0 | yg(0 | (_I = 0 | kI(C + 15 | 0)), 0 | o(), 6), o(), U = 0 | yg(0 | (U = 0 | Bg(0 | B[C + 18 >> 0], 0 | B[C + 19 >> 0], 0 | B[C + 20 >> 0])), 0 | o(), 3), o(), cI = 0 | Bg(0 | B[C + 21 >> 0], 0 | B[C + 22 >> 0], 0 | B[C + 23 >> 0]), o(), TA = 0 | yg(0 | (TA = 0 | kI(C + 23 | 0)), 0 | o(), 5), o(), tA = 0 | yg(0 | (tA = 0 | Bg(0 | B[C + 26 >> 0], 0 | B[C + 27 >> 0], 0 | B[C + 28 >> 0])), 0 | o(), 2), o(), FI = 0 | yg(0 | (FI = 0 | kI(C + 28 | 0)), 0 | o(), 7), GI = 0 | o(), mA = 0 | vg(2097151 & LA | 0, 0, 0 | (mA = 0 | Qg(2097151 & XI | 0, 0, 2097151 & wA | 0, 0)), 0 | o()), LA = 0 | o(), F = 0 | Qg(2097151 & hI | 0, 0, 2097151 & wA | 0, 0), D = 0 | o(), h = 0 | Qg(2097151 & XI | 0, 0, 2097151 & UI | 0, 0), $A = 0 | o(), Z = 0 | Qg(2097151 & gI | 0, 0, 2097151 & wA | 0, 0), xA = 0 | o(), KA = 0 | vg(0 | (xA = 0 | vg(0 | (vA = 0 | vg(0 | (O = 0 | Qg(2097151 & hI | 0, 0, 2097151 & UI | 0, 0)), 0 | o(), 0 | (vA = 0 | Qg(2097151 & XI | 0, 0, 2097151 & uI | 0, 0)), 0 | o())), 0 | o(), 0 | Z, 0 | xA)), 0 | o(), 2097151 & KA | 0, 0), xA = 0 | o(), Z = 0 | Qg(2097151 & G | 0, 0, 2097151 & wA | 0, 0), vA = 0 | o(), l = 0 | Qg(2097151 & gI | 0, 0, 2097151 & UI | 0, 0), O = 0 | o(), s = 0 | Qg(2097151 & hI | 0, 0, 2097151 & uI | 0, 0), y = 0 | o(), w = 0 | Qg(2097151 & XI | 0, 0, 2097151 & SI | 0, 0), ug = 0 | o(), aA = 0 | Qg(2097151 & d | 0, 0, 2097151 & wA | 0, 0), JA = 0 | o(), sg = 0 | Qg(2097151 & G | 0, 0, 2097151 & UI | 0, 0), OA = 0 | o(), Dg = 0 | Qg(2097151 & gI | 0, 0, 2097151 & uI | 0, 0), P = 0 | o(), PA = 0 | vg(0 | (JA = 0 | vg(0 | (OA = 0 | vg(0 | (P = 0 | vg(0 | (hg = 0 | vg(0 | (Fg = 0 | Qg(2097151 & hI | 0, 0, 2097151 & SI | 0, 0)), 0 | o(), 0 | (hg = 0 | Qg(2097151 & XI | 0, 0, 2097151 & yI | 0, 0)), 0 | o())), 0 | o(), 0 | Dg, 0 | P)), 0 | o(), 0 | sg, 0 | OA)), 0 | o(), 0 | aA, 0 | JA)), 0 | o(), 2097151 & PA | 0, 0), JA = 0 | o(), aA = 0 | Qg(2097151 & x | 0, 0, 2097151 & wA | 0, 0), OA = 0 | o(), sg = 0 | Qg(2097151 & d | 0, 0, 2097151 & UI | 0, 0), P = 0 | o(), Dg = 0 | Qg(2097151 & G | 0, 0, 2097151 & uI | 0, 0), hg = 0 | o(), k = 0 | Qg(2097151 & gI | 0, 0, 2097151 & SI | 0, 0), Fg = 0 | o(), f = 0 | Qg(2097151 & hI | 0, 0, 2097151 & yI | 0, 0), t = 0 | o(), r = 0 | Qg(2097151 & XI | 0, 0, 2097151 & CA | 0, 0), pg = 0 | o(), I = 0 | Qg(2097151 & zA | 0, 0, 2097151 & wA | 0, 0), DI = 0 | o(), Eg = 0 | Qg(2097151 & x | 0, 0, 2097151 & UI | 0, 0), Y = 0 | o(), og = 0 | Qg(2097151 & d | 0, 0, 2097151 & uI | 0, 0), S = 0 | o(), ag = 0 | Qg(2097151 & G | 0, 0, 2097151 & SI | 0, 0), eg = 0 | o(), tg = 0 | Qg(2097151 & gI | 0, 0, 2097151 & yI | 0, 0), cg = 0 | o(), _I = 0 | vg(0 | (DI = 0 | vg(0 | (Y = 0 | vg(0 | (S = 0 | vg(0 | (eg = 0 | vg(0 | (cg = 0 | vg(0 | (ng = 0 | vg(0 | (fg = 0 | Qg(2097151 & hI | 0, 0, 2097151 & CA | 0, 0)), 0 | o(), 0 | (ng = 0 | Qg(2097151 & XI | 0, 0, 2097151 & FA | 0, 0)), 0 | o())), 0 | o(), 0 | tg, 0 | cg)), 0 | o(), 0 | ag, 0 | eg)), 0 | o(), 0 | og, 0 | S)), 0 | o(), 0 | Eg, 0 | Y)), 0 | o(), 0 | I, 0 | DI)), 0 | o(), 2097151 & _I | 0, 0), DI = 0 | o(), I = 0 | Qg(2097151 & sA | 0, 0, 2097151 & wA | 0, 0), Y = 0 | o(), Eg = 0 | Qg(2097151 & zA | 0, 0, 2097151 & UI | 0, 0), S = 0 | o(), og = 0 | Qg(2097151 & x | 0, 0, 2097151 & uI | 0, 0), eg = 0 | o(), ag = 0 | Qg(2097151 & d | 0, 0, 2097151 & SI | 0, 0), cg = 0 | o(), tg = 0 | Qg(2097151 & G | 0, 0, 2097151 & yI | 0, 0), ng = 0 | o(), H = 0 | Qg(2097151 & gI | 0, 0, 2097151 & CA | 0, 0), fg = 0 | o(), n = 0 | Qg(2097151 & hI | 0, 0, 2097151 & FA | 0, 0), a = 0 | o(), c = 0 | Qg(2097151 & XI | 0, 0, 2097151 & _ | 0, 0), wg = 0 | o(), qI = 0 | Qg(2097151 & RA | 0, 0, 2097151 & wA | 0, 0), M = 0 | o(), T = 0 | Qg(2097151 & sA | 0, 0, 2097151 & UI | 0, 0), aI = 0 | o(), jI = 0 | Qg(2097151 & zA | 0, 0, 2097151 & uI | 0, 0), TI = 0 | o(), zI = 0 | Qg(2097151 & x | 0, 0, 2097151 & SI | 0, 0), j = 0 | o(), OI = 0 | Qg(2097151 & d | 0, 0, 2097151 & yI | 0, 0), VI = 0 | o(), $I = 0 | Qg(2097151 & G | 0, 0, 2097151 & CA | 0, 0), WI = 0 | o(), Ig = 0 | Qg(2097151 & gI | 0, 0, 2097151 & FA | 0, 0), ZI = 0 | o(), cI = 0 | vg(0 | (aI = 0 | vg(0 | (M = 0 | vg(0 | (TI = 0 | vg(0 | (j = 0 | vg(0 | (VI = 0 | vg(0 | (WI = 0 | vg(0 | (ZI = 0 | vg(0 | (Ag = 0 | vg(0 | (gg = 0 | Qg(2097151 & hI | 0, 0, 2097151 & _ | 0, 0)), 0 | o(), 0 | (Ag = 0 | Qg(2097151 & XI | 0, 0, 2097151 & QA | 0, 0)), 0 | o())), 0 | o(), 0 | Ig, 0 | ZI)), 0 | o(), 0 | $I, 0 | WI)), 0 | o(), 0 | OI, 0 | VI)), 0 | o(), 0 | zI, 0 | j)), 0 | o(), 0 | jI, 0 | TI)), 0 | o(), 0 | qI, 0 | M)), 0 | o(), 0 | T, 0 | aI)), 0 | o(), 2097151 & cI | 0, 0), aI = 0 | o(), T = 0 | Qg(2097151 & IA | 0, 0, 2097151 & wA | 0, 0), M = 0 | o(), qI = 0 | Qg(2097151 & RA | 0, 0, 2097151 & UI | 0, 0), TI = 0 | o(), jI = 0 | Qg(2097151 & sA | 0, 0, 2097151 & uI | 0, 0), j = 0 | o(), zI = 0 | Qg(2097151 & zA | 0, 0, 2097151 & SI | 0, 0), VI = 0 | o(), OI = 0 | Qg(2097151 & x | 0, 0, 2097151 & yI | 0, 0), WI = 0 | o(), $I = 0 | Qg(2097151 & d | 0, 0, 2097151 & CA | 0, 0), ZI = 0 | o(), Ig = 0 | Qg(2097151 & G | 0, 0, 2097151 & FA | 0, 0), Ag = 0 | o(), u = 0 | Qg(2097151 & gI | 0, 0, 2097151 & _ | 0, 0), gg = 0 | o(), e = 0 | Qg(2097151 & hI | 0, 0, 2097151 & QA | 0, 0), i = 0 | o(), E = 0 | Qg(2097151 & XI | 0, 0, 2097151 & q | 0, 0), Cg = 0 | o(), yA = 0 | Qg(2097151 & NI | 0, 0, 2097151 & wA | 0, 0), fA = 0 | o(), W = 0 | Qg(2097151 & IA | 0, 0, 2097151 & UI | 0, 0), z = 0 | o(), iI = 0 | Qg(2097151 & RA | 0, 0, 2097151 & uI | 0, 0), EI = 0 | o(), JI = 0 | Qg(2097151 & sA | 0, 0, 2097151 & SI | 0, 0), bI = 0 | o(), EA = 0 | Qg(2097151 & zA | 0, 0, 2097151 & yI | 0, 0), b = 0 | o(), lI = 0 | Qg(2097151 & x | 0, 0, 2097151 & CA | 0, 0), HI = 0 | o(), II = 0 | Qg(2097151 & d | 0, 0, 2097151 & FA | 0, 0), AI = 0 | o(), rI = 0 | Qg(2097151 & G | 0, 0, 2097151 & _ | 0, 0), nI = 0 | o(), V = 0 | Qg(2097151 & gI | 0, 0, 2097151 & QA | 0, 0), C = 0 | o(), tA = 0 | vg(0 | (fA = 0 | vg(0 | (z = 0 | vg(0 | (bI = 0 | vg(0 | (EI = 0 | vg(0 | (b = 0 | vg(0 | (HI = 0 | vg(0 | (AI = 0 | vg(0 | (nI = 0 | vg(0 | (C = 0 | vg(0 | (xI = 0 | vg(0 | Qg(2097151 & hI | 0, 0, 2097151 & q | 0, 0), 0 | (LI = 0 | o()), 0 | (xI = 0 | Qg(2097151 & XI | 0, 0, 2097151 & HA | 0, 0)), 0 | o())), 0 | o(), 0 | V, 0 | C)), 0 | o(), 0 | rI, 0 | nI)), 0 | o(), 0 | II, 0 | AI)), 0 | o(), 0 | lI, 0 | HI)), 0 | o(), 0 | EA, 0 | b)), 0 | o(), 0 | iI, 0 | EI)), 0 | o(), 0 | JI, 0 | bI)), 0 | o(), 0 | W, 0 | z)), 0 | o(), 0 | yA, 0 | fA)), 0 | o(), 2097151 & tA | 0, 0), fA = 0 | o(), wA = 0 | Qg(0 | rA, 0 | nA, 2097151 & wA | 0, 0), yA = 0 | o(), z = 0 | Qg(2097151 & NI | 0, 0, 2097151 & UI | 0, 0), W = 0 | o(), bI = 0 | Qg(2097151 & IA | 0, 0, 2097151 & uI | 0, 0), JI = 0 | o(), EI = 0 | Qg(2097151 & RA | 0, 0, 2097151 & SI | 0, 0), iI = 0 | o(), b = 0 | Qg(2097151 & sA | 0, 0, 2097151 & yI | 0, 0), EA = 0 | o(), HI = 0 | Qg(2097151 & zA | 0, 0, 2097151 & CA | 0, 0), lI = 0 | o(), AI = 0 | Qg(2097151 & x | 0, 0, 2097151 & FA | 0, 0), II = 0 | o(), nI = 0 | Qg(2097151 & d | 0, 0, 2097151 & _ | 0, 0), rI = 0 | o(), C = 0 | Qg(2097151 & G | 0, 0, 2097151 & QA | 0, 0), V = 0 | o(), xI = 0 | Qg(2097151 & gI | 0, 0, 2097151 & q | 0, 0), LI = 0 | o(), p = 0 | Qg(2097151 & hI | 0, 0, 2097151 & HA | 0, 0), Q = 0 | o(), XI = 0 | Qg(2097151 & XI | 0, 0, 0 | GA, 0 | dA), KI = 0 | o(), UI = 0 | Qg(0 | rA, 0 | nA, 2097151 & UI | 0, 0), vI = 0 | o(), hA = 0 | Qg(2097151 & NI | 0, 0, 2097151 & uI | 0, 0), pI = 0 | o(), PI = 0 | Qg(2097151 & IA | 0, 0, 2097151 & SI | 0, 0), N = 0 | o(), uA = 0 | Qg(2097151 & RA | 0, 0, 2097151 & yI | 0, 0), cA = 0 | o(), oA = 0 | Qg(2097151 & sA | 0, 0, 2097151 & CA | 0, 0), RI = 0 | o(), SA = 0 | Qg(2097151 & zA | 0, 0, 2097151 & FA | 0, 0), L = 0 | o(), kA = 0 | Qg(2097151 & x | 0, 0, 2097151 & _ | 0, 0), UA = 0 | o(), fI = 0 | Qg(2097151 & d | 0, 0, 2097151 & QA | 0, 0), YA = 0 | o(), sI = 0 | Qg(2097151 & G | 0, 0, 2097151 & q | 0, 0), tI = 0 | o(), vI = 0 | vg(0 | (pI = 0 | vg(0 | (N = 0 | vg(0 | (RI = 0 | vg(0 | (cA = 0 | vg(0 | (L = 0 | vg(0 | (UA = 0 | vg(0 | (YA = 0 | vg(0 | (tI = 0 | vg(0 | (hI = 0 | vg(0 | (MI = 0 | Qg(2097151 & gI | 0, 0, 2097151 & HA | 0, 0)), 0 | (BI = 0 | o()), 0 | (hI = 0 | Qg(2097151 & hI | 0, 0, 0 | GA, 0 | dA)), 0 | o())), 0 | o(), 0 | sI, 0 | tI)), 0 | o(), 0 | fI, 0 | YA)), 0 | o(), 0 | kA, 0 | UA)), 0 | o(), 0 | SA, 0 | L)), 0 | o(), 0 | uA, 0 | cA)), 0 | o(), 0 | oA, 0 | RI)), 0 | o(), 0 | PI, 0 | N)), 0 | o(), 0 | hA, 0 | pI)), 0 | o(), 0 | UI, 0 | vI), UI = 0 | o(), uI = 0 | Qg(0 | rA, 0 | nA, 2097151 & uI | 0, 0), pI = 0 | o(), hA = 0 | Qg(2097151 & NI | 0, 0, 2097151 & SI | 0, 0), N = 0 | o(), PI = 0 | Qg(2097151 & IA | 0, 0, 2097151 & yI | 0, 0), RI = 0 | o(), oA = 0 | Qg(2097151 & RA | 0, 0, 2097151 & CA | 0, 0), cA = 0 | o(), uA = 0 | Qg(2097151 & sA | 0, 0, 2097151 & FA | 0, 0), L = 0 | o(), SA = 0 | Qg(2097151 & zA | 0, 0, 2097151 & _ | 0, 0), UA = 0 | o(), kA = 0 | Qg(2097151 & x | 0, 0, 2097151 & QA | 0, 0), YA = 0 | o(), fI = 0 | Qg(2097151 & d | 0, 0, 2097151 & q | 0, 0), tI = 0 | o(), sI = 0 | Qg(2097151 & G | 0, 0, 2097151 & HA | 0, 0), hI = 0 | o(), gI = 0 | Qg(2097151 & gI | 0, 0, 0 | GA, 0 | dA), BI = 0 | o(), SI = 0 | Qg(0 | rA, 0 | nA, 2097151 & SI | 0, 0), MI = 0 | o(), dI = 0 | Qg(2097151 & NI | 0, 0, 2097151 & yI | 0, 0), wI = 0 | o(), K = 0 | Qg(2097151 & IA | 0, 0, 2097151 & CA | 0, 0), YI = 0 | o(), qA = 0 | Qg(2097151 & RA | 0, 0, 2097151 & FA | 0, 0), $ = 0 | o(), J = 0 | Qg(2097151 & sA | 0, 0, 2097151 & _ | 0, 0), g = 0 | o(), v = 0 | Qg(2097151 & zA | 0, 0, 2097151 & QA | 0, 0), ZA = 0 | o(), pA = 0 | Qg(2097151 & x | 0, 0, 2097151 & q | 0, 0), DA = 0 | o(), MI = 0 | vg(0 | (wI = 0 | vg(0 | (YI = 0 | vg(0 | (g = 0 | vg(0 | ($ = 0 | vg(0 | (ZA = 0 | vg(0 | (DA = 0 | vg(0 | (G = 0 | vg(0 | (mI = 0 | Qg(2097151 & d | 0, 0, 2097151 & HA | 0, 0)), 0 | (m = 0 | o()), 0 | (G = 0 | Qg(2097151 & G | 0, 0, 0 | GA, 0 | dA)), 0 | o())), 0 | o(), 0 | pA, 0 | DA)), 0 | o(), 0 | v, 0 | ZA)), 0 | o(), 0 | qA, 0 | $)), 0 | o(), 0 | J, 0 | g)), 0 | o(), 0 | K, 0 | YI)), 0 | o(), 0 | dI, 0 | wI)), 0 | o(), 0 | SI, 0 | MI), SI = 0 | o(), yI = 0 | Qg(0 | rA, 0 | nA, 2097151 & yI | 0, 0), wI = 0 | o(), dI = 0 | Qg(2097151 & NI | 0, 0, 2097151 & CA | 0, 0), YI = 0 | o(), K = 0 | Qg(2097151 & IA | 0, 0, 2097151 & FA | 0, 0), g = 0 | o(), J = 0 | Qg(2097151 & RA | 0, 0, 2097151 & _ | 0, 0), $ = 0 | o(), qA = 0 | Qg(2097151 & sA | 0, 0, 2097151 & QA | 0, 0), ZA = 0 | o(), v = 0 | Qg(2097151 & zA | 0, 0, 2097151 & q | 0, 0), DA = 0 | o(), pA = 0 | Qg(2097151 & x | 0, 0, 2097151 & HA | 0, 0), G = 0 | o(), d = 0 | Qg(2097151 & d | 0, 0, 0 | GA, 0 | dA), m = 0 | o(), CA = 0 | Qg(0 | rA, 0 | nA, 2097151 & CA | 0, 0), mI = 0 | o(), QI = 0 | Qg(2097151 & NI | 0, 0, 2097151 & FA | 0, 0), gA = 0 | o(), _A = 0 | Qg(2097151 & IA | 0, 0, 2097151 & _ | 0, 0), CI = 0 | o(), X = 0 | Qg(2097151 & RA | 0, 0, 2097151 & QA | 0, 0), iA = 0 | o(), eA = 0 | Qg(2097151 & sA | 0, 0, 2097151 & q | 0, 0), lA = 0 | o(), mI = 0 | vg(0 | (gA = 0 | vg(0 | (CI = 0 | vg(0 | (lA = 0 | vg(0 | (iA = 0 | vg(0 | (x = 0 | vg(0 | (R = 0 | Qg(2097151 & zA | 0, 0, 2097151 & HA | 0, 0)), 0 | (VA = 0 | o()), 0 | (x = 0 | Qg(2097151 & x | 0, 0, 0 | GA, 0 | dA)), 0 | o())), 0 | o(), 0 | X, 0 | iA)), 0 | o(), 0 | eA, 0 | lA)), 0 | o(), 0 | _A, 0 | CI)), 0 | o(), 0 | QI, 0 | gA)), 0 | o(), 0 | CA, 0 | mI), CA = 0 | o(), FA = 0 | Qg(0 | rA, 0 | nA, 2097151 & FA | 0, 0), gA = 0 | o(), QI = 0 | Qg(2097151 & NI | 0, 0, 2097151 & _ | 0, 0), CI = 0 | o(), _A = 0 | Qg(2097151 & IA | 0, 0, 2097151 & QA | 0, 0), lA = 0 | o(), eA = 0 | Qg(2097151 & RA | 0, 0, 2097151 & q | 0, 0), iA = 0 | o(), X = 0 | Qg(2097151 & sA | 0, 0, 2097151 & HA | 0, 0), x = 0 | o(), zA = 0 | Qg(2097151 & zA | 0, 0, 0 | GA, 0 | dA), VA = 0 | o(), _ = 0 | Qg(0 | rA, 0 | nA, 2097151 & _ | 0, 0), R = 0 | o(), XA = 0 | Qg(2097151 & NI | 0, 0, 2097151 & QA | 0, 0), AA = 0 | o(), oI = 0 | Qg(2097151 & IA | 0, 0, 2097151 & q | 0, 0), jA = 0 | o(), NA = 0 | Qg(2097151 & RA | 0, 0, 2097151 & HA | 0, 0), eI = 0 | o(), R = 0 | vg(0 | (AA = 0 | vg(0 | (jA = 0 | vg(0 | (eI = 0 | vg(0 | (sA = 0 | Qg(2097151 & sA | 0, 0, 0 | GA, 0 | dA)), 0 | o(), 0 | NA, 0 | eI)), 0 | o(), 0 | oI, 0 | jA)), 0 | o(), 0 | XA, 0 | AA)), 0 | o(), 0 | _, 0 | R), _ = 0 | o(), QA = 0 | Qg(0 | rA, 0 | nA, 2097151 & QA | 0, 0), AA = 0 | o(), XA = 0 | Qg(2097151 & NI | 0, 0, 2097151 & q | 0, 0), jA = 0 | o(), oI = 0 | Qg(2097151 & IA | 0, 0, 2097151 & HA | 0, 0), eI = 0 | o(), RA = 0 | Qg(2097151 & RA | 0, 0, 0 | GA, 0 | dA), NA = 0 | o(), q = 0 | Qg(0 | rA, 0 | nA, 2097151 & q | 0, 0), sA = 0 | o(), sA = 0 | vg(0 | (IA = 0 | vg(0 | Qg(2097151 & NI | 0, 0, 2097151 & HA | 0, 0), 0 | (MA = 0 | o()), 0 | (IA = 0 | Qg(2097151 & IA | 0, 0, 0 | GA, 0 | dA)), 0 | o())), 0 | o(), 0 | q, 0 | sA), q = 0 | o(), NI = 0 | vg(0 | (HA = 0 | Qg(0 | rA, 0 | nA, 2097151 & HA | 0, 0)), 0 | (IA = 0 | o()), 0 | (NI = 0 | Qg(2097151 & NI | 0, 0, 0 | GA, 0 | dA)), 0 | o()), IA = 0 | o(), dA = 0 | Qg(0 | rA, 0 | nA, 0 | GA, 0 | dA), GA = 0 | o(), HA = 0 | yg(0 | (nA = 0 | vg(0 | mA, 0 | LA, 1048576, 0)), 0 | (rA = 0 | o()), 21), MA = 0 | o(), MA = 0 | vg(0 | (BA = 0 | vg(0 | ($A = 0 | vg(0 | F, 0 | D, 0 | h, 0 | $A)), 0 | o(), 2097151 & BA | 0, 0)), 0 | o(), 0 | HA, 0 | MA), HA = 0 | o(), rA = 0 | Ug(0 | mA, 0 | LA, -2097152 & nA | 0, 4095 & rA | 0), nA = 0 | o(), BA = 0 | yg(0 | (LA = 0 | vg(0 | KA, 0 | xA, 1048576, 0)), 0 | (mA = 0 | o()), 21), $A = 0 | o(), $A = 0 | vg(0 | (bA = 0 | vg(0 | (vA = 0 | vg(0 | (O = 0 | vg(0 | (ug = 0 | vg(0 | s, 0 | y, 0 | w, 0 | ug)), 0 | o(), 0 | l, 0 | O)), 0 | o(), 0 | Z, 0 | vA)), 0 | o(), 2097151 & bA | 0, 0)), 0 | o(), 0 | BA, 0 | $A), BA = 0 | o(), Z = 0 | ig(0 | (bA = 0 | vg(0 | PA, 0 | JA, 1048576, 0)), 0 | (vA = 0 | o()), 21), O = 0 | o(), O = 0 | vg(0 | (WA = 0 | vg(0 | (OA = 0 | vg(0 | (P = 0 | vg(0 | (hg = 0 | vg(0 | (Fg = 0 | vg(0 | (pg = 0 | vg(0 | f, 0 | t, 0 | r, 0 | pg)), 0 | o(), 0 | k, 0 | Fg)), 0 | o(), 0 | Dg, 0 | hg)), 0 | o(), 0 | sg, 0 | P)), 0 | o(), 0 | aA, 0 | OA)), 0 | o(), 2097151 & WA | 0, 0)), 0 | o(), 0 | Z, 0 | O), Z = 0 | o(), aA = 0 | ig(0 | (WA = 0 | vg(0 | _I, 0 | DI, 1048576, 0)), 0 | (OA = 0 | o()), 21), P = 0 | o(), P = 0 | vg(0 | (U = 0 | vg(0 | (Y = 0 | vg(0 | (S = 0 | vg(0 | (eg = 0 | vg(0 | (cg = 0 | vg(0 | (ng = 0 | vg(0 | (fg = 0 | vg(0 | (wg = 0 | vg(0 | n, 0 | a, 0 | c, 0 | wg)), 0 | o(), 0 | H, 0 | fg)), 0 | o(), 0 | tg, 0 | ng)), 0 | o(), 0 | ag, 0 | cg)), 0 | o(), 0 | og, 0 | eg)), 0 | o(), 0 | Eg, 0 | S)), 0 | o(), 0 | I, 0 | Y)), 0 | o(), 2097151 & U | 0, 0)), 0 | o(), 0 | aA, 0 | P), aA = 0 | o(), I = 0 | ig(0 | (U = 0 | vg(0 | cI, 0 | aI, 1048576, 0)), 0 | (Y = 0 | o()), 21), S = 0 | o(), S = 0 | vg(0 | (TA = 0 | vg(0 | (M = 0 | vg(0 | (j = 0 | vg(0 | (TI = 0 | vg(0 | (VI = 0 | vg(0 | (WI = 0 | vg(0 | (ZI = 0 | vg(0 | (Ag = 0 | vg(0 | (gg = 0 | vg(0 | (Cg = 0 | vg(0 | e, 0 | i, 0 | E, 0 | Cg)), 0 | o(), 0 | u, 0 | gg)), 0 | o(), 0 | Ig, 0 | Ag)), 0 | o(), 0 | $I, 0 | ZI)), 0 | o(), 0 | OI, 0 | WI)), 0 | o(), 0 | zI, 0 | VI)), 0 | o(), 0 | qI, 0 | TI)), 0 | o(), 0 | jI, 0 | j)), 0 | o(), 0 | T, 0 | M)), 0 | o(), 2097151 & TA | 0, 0)), 0 | o(), 0 | I, 0 | S), I = 0 | o(), T = 0 | ig(0 | (TA = 0 | vg(0 | tA, 0 | fA, 1048576, 0)), 0 | (M = 0 | o()), 21), j = 0 | o(), j = 0 | vg(0 | (GI = 0 | vg(0 | (W = 0 | vg(0 | (yA = 0 | vg(0 | (JI = 0 | vg(0 | (EA = 0 | vg(0 | (iI = 0 | vg(0 | (lI = 0 | vg(0 | (II = 0 | vg(0 | (rI = 0 | vg(0 | (V = 0 | vg(0 | (LI = 0 | vg(0 | (KI = 0 | vg(0 | p, 0 | Q, 0 | XI, 0 | KI)), 0 | o(), 0 | xI, 0 | LI)), 0 | o(), 0 | C, 0 | V)), 0 | o(), 0 | nI, 0 | rI)), 0 | o(), 0 | AI, 0 | II)), 0 | o(), 0 | HI, 0 | lI)), 0 | o(), 0 | EI, 0 | iI)), 0 | o(), 0 | b, 0 | EA)), 0 | o(), 0 | bI, 0 | JI)), 0 | o(), 0 | wA, 0 | yA)), 0 | o(), 0 | z, 0 | W)), 0 | o(), 0 | FI, 0 | GI)), 0 | o(), 0 | T, 0 | j), T = 0 | o(), W = 0 | ig(0 | (GI = 0 | vg(0 | vI, 0 | UI, 1048576, 0)), 0 | (FI = 0 | o()), 21), z = 0 | o(), z = 0 | vg(0 | (pI = 0 | vg(0 | (N = 0 | vg(0 | (RI = 0 | vg(0 | (L = 0 | vg(0 | (cA = 0 | vg(0 | (UA = 0 | vg(0 | (YA = 0 | vg(0 | (tI = 0 | vg(0 | (BI = 0 | vg(0 | sI, 0 | hI, 0 | gI, 0 | BI)), 0 | o(), 0 | fI, 0 | tI)), 0 | o(), 0 | kA, 0 | YA)), 0 | o(), 0 | SA, 0 | UA)), 0 | o(), 0 | oA, 0 | cA)), 0 | o(), 0 | uA, 0 | L)), 0 | o(), 0 | PI, 0 | RI)), 0 | o(), 0 | hA, 0 | N)), 0 | o(), 0 | uI, 0 | pI)), 0 | o(), 0 | W, 0 | z), W = 0 | o(), N = 0 | ig(0 | (pI = 0 | vg(0 | MI, 0 | SI, 1048576, 0)), 0 | (uI = 0 | o()), 21), hA = 0 | o(), hA = 0 | vg(0 | (wI = 0 | vg(0 | (YI = 0 | vg(0 | (g = 0 | vg(0 | (ZA = 0 | vg(0 | ($ = 0 | vg(0 | (DA = 0 | vg(0 | (m = 0 | vg(0 | pA, 0 | G, 0 | d, 0 | m)), 0 | o(), 0 | v, 0 | DA)), 0 | o(), 0 | J, 0 | $)), 0 | o(), 0 | qA, 0 | ZA)), 0 | o(), 0 | K, 0 | g)), 0 | o(), 0 | dI, 0 | YI)), 0 | o(), 0 | yI, 0 | wI)), 0 | o(), 0 | N, 0 | hA), N = 0 | o(), YI = 0 | ig(0 | (wI = 0 | vg(0 | mI, 0 | CA, 1048576, 0)), 0 | (yI = 0 | o()), 21), dI = 0 | o(), dI = 0 | vg(0 | (gA = 0 | vg(0 | (CI = 0 | vg(0 | (lA = 0 | vg(0 | (x = 0 | vg(0 | (VA = 0 | vg(0 | eA, 0 | iA, 0 | zA, 0 | VA)), 0 | o(), 0 | X, 0 | x)), 0 | o(), 0 | _A, 0 | lA)), 0 | o(), 0 | QI, 0 | CI)), 0 | o(), 0 | FA, 0 | gA)), 0 | o(), 0 | YI, 0 | dI), YI = 0 | o(), CI = 0 | ig(0 | (gA = 0 | vg(0 | R, 0 | _, 1048576, 0)), 0 | (FA = 0 | o()), 21), QI = 0 | o(), QI = 0 | vg(0 | (AA = 0 | vg(0 | (jA = 0 | vg(0 | (NA = 0 | vg(0 | oI, 0 | eI, 0 | RA, 0 | NA)), 0 | o(), 0 | XA, 0 | jA)), 0 | o(), 0 | QA, 0 | AA)), 0 | o(), 0 | CI, 0 | QI), CI = 0 | o(), FA = 0 | Ug(0 | R, 0 | _, -2097152 & gA | 0, 0 | FA), gA = 0 | o(), AA = 0 | vg(0 | NI, 0 | IA, 0 | (AA = 0 | ig(0 | (_ = 0 | vg(0 | sA, 0 | q, 1048576, 0)), 0 | (R = 0 | o()), 21)), 0 | o()), IA = 0 | o(), R = 0 | Ug(0 | sA, 0 | q, -2097152 & _ | 0, 0 | R), _ = 0 | o(), NI = 0 | ig(0 | (q = 0 | vg(0 | dA, 0 | GA, 1048576, 0)), 0 | (sA = 0 | o()), 21), QA = 0 | o(), sA = 0 | Ug(0 | dA, 0 | GA, -2097152 & q | 0, 0 | sA), q = 0 | o(), jA = 0 | yg(0 | (GA = 0 | vg(0 | MA, 0 | HA, 1048576, 0)), 0 | (dA = 0 | o()), 21), XA = 0 | o(), dA = 0 | Ug(0 | MA, 0 | HA, -2097152 & GA | 0, 0 | dA), GA = 0 | o(), NA = 0 | ig(0 | (HA = 0 | vg(0 | $A, 0 | BA, 1048576, 0)), 0 | (MA = 0 | o()), 21), RA = 0 | o(), MA = 0 | Ug(0 | $A, 0 | BA, -2097152 & HA | 0, 0 | MA), HA = 0 | o(), eI = 0 | ig(0 | (BA = 0 | vg(0 | O, 0 | Z, 1048576, 0)), 0 | ($A = 0 | o()), 21), oI = 0 | o(), $A = 0 | Ug(0 | O, 0 | Z, -2097152 & BA | 0, 0 | $A), BA = 0 | o(), lA = 0 | ig(0 | (Z = 0 | vg(0 | P, 0 | aA, 1048576, 0)), 0 | (O = 0 | o()), 21), _A = 0 | o(), VA = 0 | ig(0 | (x = 0 | vg(0 | S, 0 | I, 1048576, 0)), 0 | (X = 0 | o()), 21), zA = 0 | o(), g = 0 | ig(0 | (iA = 0 | vg(0 | j, 0 | T, 1048576, 0)), 0 | (eA = 0 | o()), 21), K = 0 | o(), $ = 0 | ig(0 | (ZA = 0 | vg(0 | z, 0 | W, 1048576, 0)), 0 | (qA = 0 | o()), 21), J = 0 | o(), m = 0 | ig(0 | (DA = 0 | vg(0 | hA, 0 | N, 1048576, 0)), 0 | (v = 0 | o()), 21), d = 0 | o(), gA = 0 | vg(0 | (RI = 0 | ig(0 | (G = 0 | vg(0 | dI, 0 | YI, 1048576, 0)), 0 | (pA = 0 | o()), 21)), 0 | o(), 0 | FA, 0 | gA), FA = 0 | o(), pA = 0 | Ug(0 | dI, 0 | YI, -2097152 & G | 0, 0 | pA), G = 0 | o(), _ = 0 | vg(0 | (RI = 0 | ig(0 | (YI = 0 | vg(0 | QI, 0 | CI, 1048576, 0)), 0 | (dI = 0 | o()), 21)), 0 | o(), 0 | R, 0 | _), R = 0 | o(), dI = 0 | Ug(0 | QI, 0 | CI, -2097152 & YI | 0, 0 | dI), YI = 0 | o(), q = 0 | vg(0 | (RI = 0 | ig(0 | (CI = 0 | vg(0 | AA, 0 | IA, 1048576, 0)), 0 | (QI = 0 | o()), 21)), 0 | o(), 0 | sA, 0 | q), sA = 0 | o(), QI = 0 | Ug(0 | AA, 0 | IA, -2097152 & CI | 0, 0 | QI), CI = 0 | o(), IA = 0 | Qg(0 | NI, 0 | QA, 666643, 0), AA = 0 | o(), RI = 0 | Qg(0 | NI, 0 | QA, 470296, 0), PI = 0 | o(), L = 0 | Qg(0 | NI, 0 | QA, 654183, 0), uA = 0 | o(), cA = 0 | Qg(0 | NI, 0 | QA, -997805, -1), oA = 0 | o(), UA = 0 | Qg(0 | NI, 0 | QA, 136657, 0), SA = 0 | o(), d = 0 | vg(0 | (yI = 0 | Ug(0 | (QA = 0 | vg(0 | mI, 0 | CA, 0 | (QA = 0 | Qg(0 | NI, 0 | QA, -683901, -1)), 0 | o())), 0 | o(), -2097152 & wI | 0, 0 | yI)), 0 | o(), 0 | m, 0 | d), m = 0 | o(), yI = 0 | Qg(0 | q, 0 | sA, 666643, 0), wI = 0 | o(), QA = 0 | Qg(0 | q, 0 | sA, 470296, 0), CA = 0 | o(), mI = 0 | Qg(0 | q, 0 | sA, 654183, 0), NI = 0 | o(), YA = 0 | Qg(0 | q, 0 | sA, -997805, -1), kA = 0 | o(), tI = 0 | Qg(0 | q, 0 | sA, 136657, 0), fI = 0 | o(), sA = 0 | Qg(0 | q, 0 | sA, -683901, -1), q = 0 | o(), BI = 0 | Qg(0 | QI, 0 | CI, 666643, 0), gI = 0 | o(), hI = 0 | Qg(0 | QI, 0 | CI, 470296, 0), sI = 0 | o(), yA = 0 | Qg(0 | QI, 0 | CI, 654183, 0), wA = 0 | o(), JI = 0 | Qg(0 | QI, 0 | CI, -997805, -1), bI = 0 | o(), EA = 0 | Qg(0 | QI, 0 | CI, 136657, 0), b = 0 | o(), CI = 0 | Qg(0 | QI, 0 | CI, -683901, -1), QI = 0 | o(), J = 0 | vg(0 | (uI = 0 | Ug(0 | (QI = 0 | vg(0 | (fI = 0 | vg(0 | (oA = 0 | vg(0 | MI, 0 | SI, 0 | cA, 0 | oA)), 0 | o(), 0 | tI, 0 | fI)), 0 | o(), 0 | CI, 0 | QI)), 0 | o(), -2097152 & pI | 0, 0 | uI)), 0 | o(), 0 | $, 0 | J), $ = 0 | o(), uI = 0 | Qg(0 | _, 0 | R, 666643, 0), pI = 0 | o(), QI = 0 | Qg(0 | _, 0 | R, 470296, 0), CI = 0 | o(), fI = 0 | Qg(0 | _, 0 | R, 654183, 0), tI = 0 | o(), oA = 0 | Qg(0 | _, 0 | R, -997805, -1), cA = 0 | o(), SI = 0 | Qg(0 | _, 0 | R, 136657, 0), MI = 0 | o(), R = 0 | Qg(0 | _, 0 | R, -683901, -1), _ = 0 | o(), iI = 0 | Qg(0 | dI, 0 | YI, 666643, 0), EI = 0 | o(), lI = 0 | Qg(0 | dI, 0 | YI, 470296, 0), HI = 0 | o(), II = 0 | Qg(0 | dI, 0 | YI, 654183, 0), AI = 0 | o(), rI = 0 | Qg(0 | dI, 0 | YI, -997805, -1), nI = 0 | o(), V = 0 | Qg(0 | dI, 0 | YI, 136657, 0), C = 0 | o(), YI = 0 | Qg(0 | dI, 0 | YI, -683901, -1), dI = 0 | o(), K = 0 | vg(0 | (FI = 0 | Ug(0 | (dI = 0 | vg(0 | (MI = 0 | vg(0 | (UI = 0 | vg(0 | (bI = 0 | vg(0 | (PI = 0 | vg(0 | mI, 0 | NI, 0 | RI, 0 | PI)), 0 | o(), 0 | JI, 0 | bI)), 0 | o(), 0 | vI, 0 | UI)), 0 | o(), 0 | SI, 0 | MI)), 0 | o(), 0 | YI, 0 | dI)), 0 | o(), -2097152 & GI | 0, 0 | FI)), 0 | o(), 0 | g, 0 | K), g = 0 | o(), OA = 0 | Ug(0 | (oI = 0 | vg(0 | (FI = 0 | vg(0 | _I, 0 | DI, 0 | (FI = 0 | Qg(0 | gA, 0 | FA, 666643, 0)), 0 | o())), 0 | o(), 0 | eI, 0 | oI)), 0 | o(), -2097152 & WA | 0, 0 | OA), WA = 0 | o(), oI = 0 | Qg(0 | gA, 0 | FA, 470296, 0), eI = 0 | o(), FI = 0 | Qg(0 | gA, 0 | FA, 654183, 0), DI = 0 | o(), _A = 0 | vg(0 | (Y = 0 | Ug(0 | (aI = 0 | vg(0 | (DI = 0 | vg(0 | (pI = 0 | vg(0 | lI, 0 | HI, 0 | uI, 0 | pI)), 0 | o(), 0 | FI, 0 | DI)), 0 | o(), 0 | cI, 0 | aI)), 0 | o(), -2097152 & U | 0, 0 | Y)), 0 | o(), 0 | lA, 0 | _A), lA = 0 | o(), Y = 0 | Qg(0 | gA, 0 | FA, -997805, -1), U = 0 | o(), aI = 0 | Qg(0 | gA, 0 | FA, 136657, 0), cI = 0 | o(), M = 0 | Ug(0 | (zA = 0 | vg(0 | (fA = 0 | vg(0 | (cI = 0 | vg(0 | (nI = 0 | vg(0 | (tI = 0 | vg(0 | (wI = 0 | vg(0 | hI, 0 | sI, 0 | yI, 0 | wI)), 0 | o(), 0 | fI, 0 | tI)), 0 | o(), 0 | rI, 0 | nI)), 0 | o(), 0 | aI, 0 | cI)), 0 | o(), 0 | tA, 0 | fA)), 0 | o(), 0 | VA, 0 | zA)), 0 | o(), -2097152 & TA | 0, 0 | M), TA = 0 | o(), FA = 0 | Qg(0 | gA, 0 | FA, -683901, -1), gA = 0 | o(), fA = 0 | ig(0 | (zA = 0 | vg(0 | OA, 0 | WA, 1048576, 0)), 0 | (VA = 0 | o()), 21), tA = 0 | o(), tA = 0 | vg(0 | (O = 0 | Ug(0 | (aA = 0 | vg(0 | (EI = 0 | vg(0 | oI, 0 | eI, 0 | iI, 0 | EI)), 0 | o(), 0 | P, 0 | aA)), 0 | o(), -2097152 & Z | 0, 0 | O)), 0 | o(), 0 | fA, 0 | tA), fA = 0 | o(), aA = 0 | ig(0 | (O = 0 | vg(0 | _A, 0 | lA, 1048576, 0)), 0 | (Z = 0 | o()), 21), P = 0 | o(), P = 0 | vg(0 | (X = 0 | Ug(0 | (I = 0 | vg(0 | (U = 0 | vg(0 | (AI = 0 | vg(0 | (gI = 0 | vg(0 | QI, 0 | CI, 0 | BI, 0 | gI)), 0 | o(), 0 | II, 0 | AI)), 0 | o(), 0 | Y, 0 | U)), 0 | o(), 0 | S, 0 | I)), 0 | o(), -2097152 & x | 0, 0 | X)), 0 | o(), 0 | aA, 0 | P), aA = 0 | o(), I = 0 | ig(0 | (X = 0 | vg(0 | M, 0 | TA, 1048576, 0)), 0 | (x = 0 | o()), 21), S = 0 | o(), S = 0 | vg(0 | (eA = 0 | Ug(0 | (T = 0 | vg(0 | (gA = 0 | vg(0 | (C = 0 | vg(0 | (cA = 0 | vg(0 | (wA = 0 | vg(0 | (AA = 0 | vg(0 | QA, 0 | CA, 0 | IA, 0 | AA)), 0 | o(), 0 | yA, 0 | wA)), 0 | o(), 0 | oA, 0 | cA)), 0 | o(), 0 | V, 0 | C)), 0 | o(), 0 | FA, 0 | gA)), 0 | o(), 0 | j, 0 | T)), 0 | o(), -2097152 & iA | 0, 0 | eA)), 0 | o(), 0 | I, 0 | S), I = 0 | o(), T = 0 | ig(0 | (eA = 0 | vg(0 | K, 0 | g, 1048576, 0)), 0 | (iA = 0 | o()), 21), j = 0 | o(), j = 0 | vg(0 | (qA = 0 | Ug(0 | (W = 0 | vg(0 | (_ = 0 | vg(0 | (b = 0 | vg(0 | (uA = 0 | vg(0 | YA, 0 | kA, 0 | L, 0 | uA)), 0 | o(), 0 | EA, 0 | b)), 0 | o(), 0 | R, 0 | _)), 0 | o(), 0 | z, 0 | W)), 0 | o(), -2097152 & ZA | 0, 0 | qA)), 0 | o(), 0 | T, 0 | j), T = 0 | o(), iA = 0 | Ug(0 | K, 0 | g, -2097152 & eA | 0, 0 | iA), eA = 0 | o(), qA = 0 | ig(0 | (g = 0 | vg(0 | J, 0 | $, 1048576, 0)), 0 | (K = 0 | o()), 21), ZA = 0 | o(), ZA = 0 | vg(0 | (v = 0 | Ug(0 | (N = 0 | vg(0 | (SA = 0 | vg(0 | sA, 0 | q, 0 | UA, 0 | SA)), 0 | o(), 0 | hA, 0 | N)), 0 | o(), -2097152 & DA | 0, 0 | v)), 0 | o(), 0 | qA, 0 | ZA), qA = 0 | o(), K = 0 | Ug(0 | J, 0 | $, -2097152 & g | 0, 0 | K), g = 0 | o(), G = 0 | vg(0 | (v = 0 | ig(0 | ($ = 0 | vg(0 | d, 0 | m, 1048576, 0)), 0 | (J = 0 | o()), 21)), 0 | o(), 0 | pA, 0 | G), pA = 0 | o(), J = 0 | Ug(0 | d, 0 | m, -2097152 & $ | 0, 0 | J), $ = 0 | o(), v = 0 | ig(0 | (m = 0 | vg(0 | tA, 0 | fA, 1048576, 0)), 0 | (d = 0 | o()), 21), DA = 0 | o(), SA = 0 | ig(0 | (N = 0 | vg(0 | P, 0 | aA, 1048576, 0)), 0 | (hA = 0 | o()), 21), UA = 0 | o(), eA = 0 | vg(0 | (W = 0 | ig(0 | (q = 0 | vg(0 | S, 0 | I, 1048576, 0)), 0 | (sA = 0 | o()), 21)), 0 | o(), 0 | iA, 0 | eA), iA = 0 | o(), sA = 0 | Ug(0 | S, 0 | I, -2097152 & q | 0, 0 | sA), q = 0 | o(), g = 0 | vg(0 | (W = 0 | ig(0 | (I = 0 | vg(0 | j, 0 | T, 1048576, 0)), 0 | (S = 0 | o()), 21)), 0 | o(), 0 | K, 0 | g), K = 0 | o(), S = 0 | Ug(0 | j, 0 | T, -2097152 & I | 0, 0 | S), I = 0 | o(), $ = 0 | vg(0 | (W = 0 | ig(0 | (T = 0 | vg(0 | ZA, 0 | qA, 1048576, 0)), 0 | (j = 0 | o()), 21)), 0 | o(), 0 | J, 0 | $), J = 0 | o(), j = 0 | Ug(0 | ZA, 0 | qA, -2097152 & T | 0, 0 | j), T = 0 | o(), qA = 0 | vg(0 | $A, 0 | BA, 0 | (qA = 0 | Qg(0 | G, 0 | pA, 666643, 0)), 0 | o()), BA = 0 | o(), $A = 0 | Qg(0 | G, 0 | pA, 470296, 0), ZA = 0 | o(), W = 0 | Qg(0 | G, 0 | pA, 654183, 0), z = 0 | o(), _ = 0 | Qg(0 | G, 0 | pA, -997805, -1), R = 0 | o(), b = 0 | Qg(0 | G, 0 | pA, 136657, 0), EA = 0 | o(), x = 0 | Ug(0 | (UA = 0 | vg(0 | (pA = 0 | vg(0 | M, 0 | TA, 0 | (pA = 0 | Qg(0 | G, 0 | pA, -683901, -1)), 0 | o())), 0 | o(), 0 | SA, 0 | UA)), 0 | o(), -2097152 & X | 0, 0 | x), X = 0 | o(), UA = 0 | Qg(0 | $, 0 | J, 666643, 0), SA = 0 | o(), pA = 0 | vg(0 | qA, 0 | BA, 0 | (pA = 0 | Qg(0 | $, 0 | J, 470296, 0)), 0 | o()), BA = 0 | o(), qA = 0 | Qg(0 | $, 0 | J, 654183, 0), TA = 0 | o(), M = 0 | Qg(0 | $, 0 | J, -997805, -1), G = 0 | o(), uA = 0 | Qg(0 | $, 0 | J, 136657, 0), L = 0 | o(), J = 0 | Qg(0 | $, 0 | J, -683901, -1), $ = 0 | o(), kA = 0 | vg(0 | MA, 0 | HA, 0 | (kA = 0 | Qg(0 | j, 0 | T, 666643, 0)), 0 | o()), HA = 0 | o(), MA = 0 | Qg(0 | j, 0 | T, 470296, 0), YA = 0 | o(), gA = 0 | vg(0 | pA, 0 | BA, 0 | (gA = 0 | Qg(0 | j, 0 | T, 654183, 0)), 0 | o()), BA = 0 | o(), pA = 0 | Qg(0 | j, 0 | T, -997805, -1), FA = 0 | o(), C = 0 | Qg(0 | j, 0 | T, 136657, 0), V = 0 | o(), T = 0 | Qg(0 | j, 0 | T, -683901, -1), j = 0 | o(), j = 0 | vg(0 | (L = 0 | vg(0 | (Z = 0 | Ug(0 | (DA = 0 | vg(0 | (R = 0 | vg(0 | _A, 0 | lA, 0 | _, 0 | R)), 0 | o(), 0 | v, 0 | DA)), 0 | o(), -2097152 & O | 0, 0 | Z)), 0 | o(), 0 | uA, 0 | L)), 0 | o(), 0 | T, 0 | j), T = 0 | o(), L = 0 | Qg(0 | g, 0 | K, 666643, 0), uA = 0 | o(), Z = 0 | Qg(0 | g, 0 | K, 470296, 0), O = 0 | o(), DA = 0 | Qg(0 | g, 0 | K, 654183, 0), v = 0 | o(), R = 0 | Qg(0 | g, 0 | K, -997805, -1), _ = 0 | o(), lA = 0 | Qg(0 | g, 0 | K, 136657, 0), _A = 0 | o(), K = 0 | Qg(0 | g, 0 | K, -683901, -1), g = 0 | o(), cA = 0 | Qg(0 | S, 0 | I, 666643, 0), oA = 0 | o(), wA = 0 | Qg(0 | S, 0 | I, 470296, 0), yA = 0 | o(), AA = 0 | Qg(0 | S, 0 | I, 654183, 0), IA = 0 | o(), CA = 0 | Qg(0 | S, 0 | I, -997805, -1), QA = 0 | o(), U = 0 | Qg(0 | S, 0 | I, 136657, 0), Y = 0 | o(), I = 0 | Qg(0 | S, 0 | I, -683901, -1), S = 0 | o(), S = 0 | vg(0 | (_A = 0 | vg(0 | (FA = 0 | vg(0 | (TA = 0 | vg(0 | (VA = 0 | Ug(0 | (WA = 0 | vg(0 | $A, 0 | ZA, 0 | OA, 0 | WA)), 0 | o(), -2097152 & zA | 0, 0 | VA)), 0 | o(), 0 | qA, 0 | TA)), 0 | o(), 0 | pA, 0 | FA)), 0 | o(), 0 | lA, 0 | _A)), 0 | o(), 0 | I, 0 | S), I = 0 | o(), nA = 0 | vg(0 | (_A = 0 | Qg(0 | eA, 0 | iA, 666643, 0)), 0 | o(), 0 | rA, 0 | nA), rA = 0 | o(), _A = 0 | Qg(0 | eA, 0 | iA, 470296, 0), lA = 0 | o(), FA = 0 | Qg(0 | eA, 0 | iA, 654183, 0), pA = 0 | o(), yA = 0 | vg(0 | (uA = 0 | vg(0 | (pA = 0 | vg(0 | (mA = 0 | Ug(0 | (xA = 0 | vg(0 | jA, 0 | XA, 0 | KA, 0 | xA)), 0 | o(), -2097152 & LA | 0, 0 | mA)), 0 | o(), 0 | FA, 0 | pA)), 0 | o(), 0 | L, 0 | uA)), 0 | o(), 0 | wA, 0 | yA), wA = 0 | o(), uA = 0 | Qg(0 | eA, 0 | iA, -997805, -1), L = 0 | o(), pA = 0 | Qg(0 | eA, 0 | iA, 136657, 0), FA = 0 | o(), QA = 0 | vg(0 | (v = 0 | vg(0 | (FA = 0 | vg(0 | (YA = 0 | vg(0 | (SA = 0 | vg(0 | (vA = 0 | Ug(0 | (JA = 0 | vg(0 | NA, 0 | RA, 0 | PA, 0 | JA)), 0 | o(), -2097152 & bA | 0, 0 | vA)), 0 | o(), 0 | UA, 0 | SA)), 0 | o(), 0 | MA, 0 | YA)), 0 | o(), 0 | pA, 0 | FA)), 0 | o(), 0 | DA, 0 | v)), 0 | o(), 0 | CA, 0 | QA), CA = 0 | o(), iA = 0 | Qg(0 | eA, 0 | iA, -683901, -1), eA = 0 | o(), FA = 0 | ig(0 | (v = 0 | vg(0 | nA, 0 | rA, 1048576, 0)), 0 | (DA = 0 | o()), 21), pA = 0 | o(), pA = 0 | vg(0 | (oA = 0 | vg(0 | (lA = 0 | vg(0 | dA, 0 | GA, 0 | _A, 0 | lA)), 0 | o(), 0 | cA, 0 | oA)), 0 | o(), 0 | FA, 0 | pA), FA = 0 | o(), DA = 0 | Ug(0 | nA, 0 | rA, -2097152 & v | 0, 0 | DA), v = 0 | o(), oA = 0 | ig(0 | (rA = 0 | vg(0 | yA, 0 | wA, 1048576, 0)), 0 | (nA = 0 | o()), 21), cA = 0 | o(), cA = 0 | vg(0 | (IA = 0 | vg(0 | (O = 0 | vg(0 | (L = 0 | vg(0 | kA, 0 | HA, 0 | uA, 0 | L)), 0 | o(), 0 | Z, 0 | O)), 0 | o(), 0 | AA, 0 | IA)), 0 | o(), 0 | oA, 0 | cA), oA = 0 | o(), O = 0 | ig(0 | (IA = 0 | vg(0 | QA, 0 | CA, 1048576, 0)), 0 | (AA = 0 | o()), 21), Z = 0 | o(), Z = 0 | vg(0 | (Y = 0 | vg(0 | (_ = 0 | vg(0 | (eA = 0 | vg(0 | gA, 0 | BA, 0 | iA, 0 | eA)), 0 | o(), 0 | R, 0 | _)), 0 | o(), 0 | U, 0 | Y)), 0 | o(), 0 | O, 0 | Z), O = 0 | o(), _ = 0 | ig(0 | (Y = 0 | vg(0 | S, 0 | I, 1048576, 0)), 0 | (U = 0 | o()), 21), R = 0 | o(), R = 0 | vg(0 | (g = 0 | vg(0 | (V = 0 | vg(0 | (G = 0 | vg(0 | (d = 0 | Ug(0 | (z = 0 | vg(0 | tA, 0 | fA, 0 | W, 0 | z)), 0 | o(), -2097152 & m | 0, 0 | d)), 0 | o(), 0 | M, 0 | G)), 0 | o(), 0 | C, 0 | V)), 0 | o(), 0 | K, 0 | g)), 0 | o(), 0 | _, 0 | R), _ = 0 | o(), U = 0 | Ug(0 | S, 0 | I, -2097152 & Y | 0, 0 | U), Y = 0 | o(), g = 0 | ig(0 | (I = 0 | vg(0 | j, 0 | T, 1048576, 0)), 0 | (S = 0 | o()), 21), K = 0 | o(), K = 0 | vg(0 | (hA = 0 | Ug(0 | (aA = 0 | vg(0 | (EA = 0 | vg(0 | J, 0 | $, 0 | b, 0 | EA)), 0 | o(), 0 | P, 0 | aA)), 0 | o(), -2097152 & N | 0, 0 | hA)), 0 | o(), 0 | g, 0 | K), g = 0 | o(), S = 0 | Ug(0 | j, 0 | T, -2097152 & I | 0, 0 | S), I = 0 | o(), hA = 0 | vg(0 | sA, 0 | q, 0 | (hA = 0 | ig(0 | (T = 0 | vg(0 | x, 0 | X, 1048576, 0)), 0 | (j = 0 | o()), 21)), 0 | o()), q = 0 | o(), aA = 0 | ig(0 | (sA = 0 | vg(0 | pA, 0 | FA, 1048576, 0)), 0 | (N = 0 | o()), 21), P = 0 | o(), $ = 0 | ig(0 | (EA = 0 | vg(0 | cA, 0 | oA, 1048576, 0)), 0 | (b = 0 | o()), 21), J = 0 | o(), G = 0 | vg(0 | U, 0 | Y, 0 | (G = 0 | ig(0 | (V = 0 | vg(0 | Z, 0 | O, 1048576, 0)), 0 | (C = 0 | o()), 21)), 0 | o()), Y = 0 | o(), d = 0 | vg(0 | S, 0 | I, 0 | (d = 0 | ig(0 | (U = 0 | vg(0 | R, 0 | _, 1048576, 0)), 0 | (M = 0 | o()), 21)), 0 | o()), I = 0 | o(), M = 0 | Ug(0 | R, 0 | _, -2097152 & U | 0, 0 | M), U = 0 | o(), S = 0 | ig(0 | (_ = 0 | vg(0 | K, 0 | g, 1048576, 0)), 0 | (R = 0 | o()), 21), m = 0 | o(), R = 0 | Ug(0 | K, 0 | g, -2097152 & _ | 0, 0 | R), _ = 0 | o(), z = 0 | ig(0 | (g = 0 | vg(0 | hA, 0 | q, 1048576, 0)), 0 | (K = 0 | o()), 21), W = 0 | o(), K = 0 | Ug(0 | hA, 0 | q, -2097152 & g | 0, 0 | K), g = 0 | o(), q = 0 | vg(0 | DA, 0 | v, 0 | (q = 0 | Qg(0 | z, 0 | W, 666643, 0)), 0 | o()), v = 0 | o(), DA = 0 | Qg(0 | z, 0 | W, 470296, 0), hA = 0 | o(), fA = 0 | Qg(0 | z, 0 | W, 654183, 0), tA = 0 | o(), eA = 0 | Qg(0 | z, 0 | W, -997805, -1), iA = 0 | o(), BA = 0 | Qg(0 | z, 0 | W, 136657, 0), gA = 0 | o(), W = 0 | Qg(0 | z, 0 | W, -683901, -1), z = 0 | o(), v = 0 | ig(0 | q, 0 | v, 21), L = 0 | o(), v = 0 | ig(0 | (L = 0 | vg(0 | (N = 0 | Ug(0 | (hA = 0 | vg(0 | pA, 0 | FA, 0 | DA, 0 | hA)), 0 | o(), -2097152 & sA | 0, 0 | N)), 0 | o(), 0 | v, 0 | L)), 0 | o(), 21), N = 0 | o(), v = 0 | ig(0 | (N = 0 | vg(0 | (P = 0 | vg(0 | (nA = 0 | Ug(0 | (tA = 0 | vg(0 | yA, 0 | wA, 0 | fA, 0 | tA)), 0 | o(), -2097152 & rA | 0, 0 | nA)), 0 | o(), 0 | aA, 0 | P)), 0 | o(), 0 | v, 0 | N)), 0 | o(), 21), P = 0 | o(), v = 0 | ig(0 | (P = 0 | vg(0 | (b = 0 | Ug(0 | (iA = 0 | vg(0 | cA, 0 | oA, 0 | eA, 0 | iA)), 0 | o(), -2097152 & EA | 0, 0 | b)), 0 | o(), 0 | v, 0 | P)), 0 | o(), 21), b = 0 | o(), v = 0 | ig(0 | (b = 0 | vg(0 | (J = 0 | vg(0 | (AA = 0 | Ug(0 | (gA = 0 | vg(0 | QA, 0 | CA, 0 | BA, 0 | gA)), 0 | o(), -2097152 & IA | 0, 0 | AA)), 0 | o(), 0 | $, 0 | J)), 0 | o(), 0 | v, 0 | b)), 0 | o(), 21), J = 0 | o(), R = 0 | ig(0 | (_ = 0 | vg(0 | (I = 0 | ig(0 | (M = 0 | vg(0 | d, 0 | I, 0 | (M = 0 | ig(0 | (U = 0 | vg(0 | (Y = 0 | ig(0 | (v = 0 | vg(0 | G, 0 | Y, 0 | (v = 0 | ig(0 | (J = 0 | vg(0 | (C = 0 | Ug(0 | (z = 0 | vg(0 | Z, 0 | O, 0 | W, 0 | z)), 0 | o(), -2097152 & V | 0, 0 | C)), 0 | o(), 0 | v, 0 | J)), 0 | o(), 21)), 0 | o())), 0 | o(), 21)), 0 | o(), 0 | M, 0 | U)), 0 | o(), 21)), 0 | o())), 0 | o(), 21)), 0 | o(), 0 | R, 0 | _)), 0 | o(), 21), I = 0 | o(), q = 0 | vg(0 | (j = 0 | Qg(0 | (K = 0 | ig(0 | (g = 0 | vg(0 | (R = 0 | ig(0 | (I = 0 | vg(0 | (j = 0 | Ug(0 | (X = 0 | vg(0 | S, 0 | m, 0 | x, 0 | X)), 0 | o(), -2097152 & T | 0, 0 | j)), 0 | o(), 0 | R, 0 | I)), 0 | o(), 21)), 0 | o(), 0 | K, 0 | g)), 0 | o(), 21)), 0 | (R = 0 | o()), 666643, 0)), 0 | o(), 2097151 & q | 0, 0), j = 0 | o(), L = 0 | vg(0 | (T = 0 | Qg(0 | K, 0 | R, 470296, 0)), 0 | o(), 2097151 & L | 0, 0), T = 0 | o(), N = 0 | vg(0 | (X = 0 | Qg(0 | K, 0 | R, 654183, 0)), 0 | o(), 2097151 & N | 0, 0), X = 0 | o(), P = 0 | vg(0 | (x = 0 | Qg(0 | K, 0 | R, -997805, -1)), 0 | o(), 2097151 & P | 0, 0), x = 0 | o(), b = 0 | vg(0 | (m = 0 | Qg(0 | K, 0 | R, 136657, 0)), 0 | o(), 2097151 & b | 0, 0), m = 0 | o(), g = 0 | vg(0 | (C = 0 | ig(0 | (I = 0 | vg(0 | (G = 0 | ig(0 | (_ = 0 | vg(0 | (Y = 0 | ig(0 | (M = 0 | vg(0 | (d = 0 | ig(0 | (U = 0 | vg(0 | (S = 0 | ig(0 | (v = 0 | vg(0 | (J = 0 | ig(0 | (b = 0 | vg(0 | (J = 0 | vg(0 | (R = 0 | Qg(0 | K, 0 | R, -683901, -1)), 0 | o(), 2097151 & J | 0, 0)), 0 | (R = 0 | o()), 0 | (b = 0 | ig(0 | (P = 0 | vg(0 | b, 0 | m, 0 | (P = 0 | ig(0 | (N = 0 | vg(0 | P, 0 | x, 0 | (N = 0 | ig(0 | (L = 0 | vg(0 | N, 0 | X, 0 | (L = 0 | ig(0 | (K = 0 | vg(0 | L, 0 | T, 0 | (K = 0 | ig(0 | q, 0 | j, 21)), 0 | o())), 0 | (T = 0 | o()), 21)), 0 | o())), 0 | (X = 0 | o()), 21)), 0 | o())), 0 | (x = 0 | o()), 21)), 0 | o())), 0 | (m = 0 | o()), 21)), 0 | o())), 0 | (R = 0 | o()), 21)), 0 | o(), 2097151 & v | 0, 0)), 0 | (J = 0 | o()), 21)), 0 | o(), 2097151 & U | 0, 0)), 0 | (S = 0 | o()), 21)), 0 | o(), 2097151 & M | 0, 0)), 0 | (d = 0 | o()), 21)), 0 | o(), 2097151 & _ | 0, 0)), 0 | (Y = 0 | o()), 21)), 0 | o(), 2097151 & I | 0, 0)), 0 | (G = 0 | o()), 21)), 0 | o(), 2097151 & g | 0, 0), C = 0 | o(), B[A >> 0] = q, V = 0 | yg(0 | q, 0 | j, 8), o(), B[A + 1 >> 0] = V, j = 0 | yg(0 | q, 0 | j, 16), o(), q = 0 | rg(2097151 & K | 0, 0, 5), o(), B[A + 2 >> 0] = q | 31 & j, j = 0 | yg(0 | K, 0 | T, 3), o(), B[A + 3 >> 0] = j, T = 0 | yg(0 | K, 0 | T, 11), o(), B[A + 4 >> 0] = T, K = 0 | yg(2097151 & K | 0, 0, 19), T = 0 | o(), j = 0 | rg(2097151 & L | 0, 0, 2), o(), B[A + 5 >> 0] = j | K, X = 0 | yg(0 | L, 0 | X, 6), o(), B[A + 6 >> 0] = X, L = 0 | yg(2097151 & L | 0, 0, 14), X = 0 | o(), K = 0 | rg(2097151 & N | 0, 0, 7), o(), B[A + 7 >> 0] = K | L, L = 0 | yg(0 | N, 0 | x, 1), o(), B[A + 8 >> 0] = L, x = 0 | yg(0 | N, 0 | x, 9), o(), B[A + 9 >> 0] = x, N = 0 | yg(2097151 & N | 0, 0, 17), x = 0 | o(), L = 0 | rg(2097151 & P | 0, 0, 4), o(), B[A + 10 >> 0] = L | N, N = 0 | yg(0 | P, 0 | m, 4), o(), B[A + 11 >> 0] = N, m = 0 | yg(0 | P, 0 | m, 12), o(), B[A + 12 >> 0] = m, P = 0 | yg(2097151 & P | 0, 0, 20), m = 0 | o(), N = 0 | rg(2097151 & b | 0, 0, 1), o(), B[A + 13 >> 0] = N | P, R = 0 | yg(0 | b, 0 | R, 7), o(), B[A + 14 >> 0] = R, b = 0 | yg(2097151 & b | 0, 0, 15), R = 0 | o(), P = 0 | rg(2097151 & v | 0, 0, 6), o(), B[A + 15 >> 0] = P | b, b = 0 | yg(0 | v, 0 | J, 2), o(), B[A + 16 >> 0] = b, J = 0 | yg(0 | v, 0 | J, 10), o(), B[A + 17 >> 0] = J, v = 0 | yg(2097151 & v | 0, 0, 18), J = 0 | o(), b = 0 | rg(0 | U, 0 | S, 3), o(), B[A + 18 >> 0] = b | v, v = 0 | yg(0 | U, 0 | S, 5), o(), B[A + 19 >> 0] = v, S = 0 | yg(0 | U, 0 | S, 13), o(), B[A + 20 >> 0] = S, B[A + 21 >> 0] = M, S = 0 | yg(0 | M, 0 | d, 8), o(), B[A + 22 >> 0] = S, d = 0 | yg(0 | M, 0 | d, 16), o(), M = 0 | rg(2097151 & _ | 0, 0, 5), o(), B[A + 23 >> 0] = M | 31 & d, d = 0 | yg(0 | _, 0 | Y, 3), o(), B[A + 24 >> 0] = d, Y = 0 | yg(0 | _, 0 | Y, 11), o(), B[A + 25 >> 0] = Y, _ = 0 | yg(2097151 & _ | 0, 0, 19), Y = 0 | o(), d = 0 | rg(2097151 & I | 0, 0, 2), o(), B[A + 26 >> 0] = d | _, G = 0 | yg(0 | I, 0 | G, 6), o(), B[A + 27 >> 0] = G, I = 0 | yg(2097151 & I | 0, 0, 14), G = 0 | o(), _ = 0 | rg(0 | g, 0 | C, 7), o(), B[A + 28 >> 0] = _ | I, I = 0 | yg(0 | g, 0 | C, 1), o(), B[A + 29 >> 0] = I, I = 0 | yg(0 | g, 0 | C, 9), o(), B[A + 30 >> 0] = I, C = 0 | ig(0 | g, 0 | C, 17), o(), B[A + 31 >> 0] = C;
          }

          function D(A, I, g, B) {
            A |= 0, B |= 0;
            var Q = 0,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0,
                m = 0,
                L = 0,
                x = 0,
                K = 0,
                X = 0;
            !function (A, I) {
              A |= 0, I |= 0;
              var g = 0,
                  B = 0,
                  Q = 0,
                  E = 0;
              g = 0;

              do {
                E = 0 | jA(I + (g << 3) | 0), Q = 0 | o(), C[(B = A + (g << 3) | 0) >> 2] = E, C[B + 4 >> 2] = Q, g = g + 1 | 0;
              } while (16 != (0 | g));
            }(g |= 0, I |= 0), Q = A, E = (I = B) + 64 | 0;

            do {
              C[I >> 2] = C[Q >> 2], I = I + 4 | 0, Q = Q + 4 | 0;
            } while ((0 | I) < (0 | E));

            I = 0 | C[g >> 2], Q = 0 | C[g + 4 >> 2], D = 0;

            do {
              if (y = 0 | ZI(H = 0 | C[B + 32 >> 2], e = 0 | C[B + 32 + 4 >> 2], 14), r = 0 | o(), G = 0 | ZI(H, e, 18), r = (0 | o()) ^ r, L = 0 | ZI(H, e, 41), r ^= 0 | o(), b = 0 | C[B + 40 >> 2], i = 0 | C[B + 40 + 4 >> 2], h = 0 | C[B + 48 >> 2], E = 0 | C[B + 48 + 4 >> 2], c = 0 | C[(P = 32416 + (D << 3) | 0) >> 2], P = 0 | C[P + 4 >> 2], t = 0 | C[B + 56 >> 2], u = 0 | C[B + 56 + 4 >> 2], P = 0 | vg(0 | (u = 0 | vg(0 | (P = 0 | vg(0 | (P = 0 | vg(0 | (r = 0 | vg(0 | I, 0 | Q, G ^ y ^ L | 0, 0 | r)), 0 | o(), 0 | c, 0 | P)), 0 | o(), (h ^ b) & H ^ h | 0, (E ^ i) & e ^ E | 0)), 0 | o(), 0 | t, 0 | u)), 0 | (t = 0 | o()), 0 | C[B + 24 >> 2], 0 | C[B + 24 + 4 >> 2]), c = 0 | o(), C[B + 24 >> 2] = P, C[B + 24 + 4 >> 2] = c, y = 0 | ZI(r = 0 | C[B >> 2], L = 0 | C[B + 4 >> 2], 28), I = 0 | o(), G = 0 | ZI(r, L, 34), I = (0 | o()) ^ I, U = 0 | ZI(r, L, 39), I ^= 0 | o(), n = 0 | C[B + 8 >> 2], m = 0 | C[B + 8 + 4 >> 2], a = 0 | C[B + 16 >> 2], N = 0 | C[B + 16 + 4 >> 2], t = 0 | vg(0 | (t = 0 | vg(G ^ y ^ U | 0, 0 | I, 0 | u, 0 | t)), 0 | o(), (a | n) & r | a & n | 0, (N | m) & L | N & m | 0), u = 0 | o(), C[B + 56 >> 2] = t, C[B + 56 + 4 >> 2] = u, I = 0 | ZI(P, c, 14), U = 0 | o(), y = 0 | ZI(P, c, 18), U = (0 | o()) ^ U, G = 0 | ZI(P, c, 41), U ^= 0 | o(), f = 0 | C[g + ((w = 1 | D) << 3) >> 2], Q = 0 | C[g + (w << 3) + 4 >> 2], s = 0 | C[32416 + (w << 3) >> 2], d = 0 | C[32416 + (w << 3) + 4 >> 2], N = 0 | vg(0 | (d = 0 | vg(0 | (Q = 0 | vg(0 | (U = 0 | vg(0 | (E = 0 | vg(P & (b ^ H) ^ b | 0, c & (i ^ e) ^ i | 0, 0 | h, 0 | E)), 0 | o(), y ^ I ^ G | 0, 0 | U)), 0 | o(), 0 | f, 0 | Q)), 0 | o(), 0 | s, 0 | d)), 0 | (s = 0 | o()), 0 | a, 0 | N), a = 0 | o(), C[B + 16 >> 2] = N, C[B + 16 + 4 >> 2] = a, Q = 0 | ZI(t, u, 28), f = 0 | o(), U = 0 | ZI(t, u, 34), f = (0 | o()) ^ f, G = 0 | ZI(t, u, 39), f ^= 0 | o(), f = 0 | vg(0 | (s = 0 | vg(0 | d, 0 | s, t & (n | r) | n & r | 0, u & (m | L) | m & L | 0)), 0 | o(), U ^ Q ^ G | 0, 0 | f), G = 0 | o(), C[B + 48 >> 2] = f, C[B + 48 + 4 >> 2] = G, Q = 0 | ZI(N, a, 14), U = 0 | o(), s = 0 | ZI(N, a, 18), U = (0 | o()) ^ U, d = 0 | ZI(N, a, 41), U ^= 0 | o(), y = 0 | C[g + ((I = 2 | D) << 3) >> 2], E = 0 | C[g + (I << 3) + 4 >> 2], h = 0 | C[32416 + (I << 3) >> 2], Y = 0 | C[32416 + (I << 3) + 4 >> 2], m = 0 | vg(0 | (Y = 0 | vg(0 | (E = 0 | vg(0 | (U = 0 | vg(0 | (i = 0 | vg(N & (P ^ H) ^ H | 0, a & (c ^ e) ^ e | 0, 0 | b, 0 | i)), 0 | o(), s ^ Q ^ d | 0, 0 | U)), 0 | o(), 0 | y, 0 | E)), 0 | o(), 0 | h, 0 | Y)), 0 | (h = 0 | o()), 0 | n, 0 | m), n = 0 | o(), C[B + 8 >> 2] = m, C[B + 8 + 4 >> 2] = n, E = 0 | ZI(f, G, 28), y = 0 | o(), U = 0 | ZI(f, G, 34), y = (0 | o()) ^ y, d = 0 | ZI(f, G, 39), y ^= 0 | o(), y = 0 | vg(0 | (h = 0 | vg(0 | Y, 0 | h, f & (t | r) | t & r | 0, G & (u | L) | u & L | 0)), 0 | o(), U ^ E ^ d | 0, 0 | y), d = 0 | o(), C[B + 40 >> 2] = y, C[B + 40 + 4 >> 2] = d, E = 0 | ZI(m, n, 14), U = 0 | o(), h = 0 | ZI(m, n, 18), U = (0 | o()) ^ U, Y = 0 | ZI(m, n, 41), U ^= 0 | o(), s = 0 | C[g + ((Q = 3 | D) << 3) >> 2], i = 0 | C[g + (Q << 3) + 4 >> 2], b = 0 | C[32416 + (Q << 3) >> 2], F = 0 | C[32416 + (Q << 3) + 4 >> 2], L = 0 | vg(0 | (F = 0 | vg(0 | (i = 0 | vg(0 | (U = 0 | vg(0 | (e = 0 | vg(m & (N ^ P) ^ P | 0, n & (a ^ c) ^ c | 0, 0 | H, 0 | e)), 0 | o(), h ^ E ^ Y | 0, 0 | U)), 0 | o(), 0 | s, 0 | i)), 0 | o(), 0 | b, 0 | F)), 0 | (b = 0 | o()), 0 | r, 0 | L), r = 0 | o(), C[B >> 2] = L, C[B + 4 >> 2] = r, i = 0 | ZI(y, d, 28), s = 0 | o(), U = 0 | ZI(y, d, 34), s = (0 | o()) ^ s, Y = 0 | ZI(y, d, 39), s ^= 0 | o(), s = 0 | vg(0 | (b = 0 | vg(0 | F, 0 | b, y & (f | t) | f & t | 0, d & (G | u) | G & u | 0)), 0 | o(), U ^ i ^ Y | 0, 0 | s), Y = 0 | o(), C[B + 32 >> 2] = s, C[B + 32 + 4 >> 2] = Y, i = 0 | ZI(L, r, 14), U = 0 | o(), b = 0 | ZI(L, r, 18), U = (0 | o()) ^ U, F = 0 | ZI(L, r, 41), U ^= 0 | o(), h = 0 | C[g + ((E = 4 | D) << 3) >> 2], e = 0 | C[g + (E << 3) + 4 >> 2], H = 0 | C[32416 + (E << 3) >> 2], J = 0 | C[32416 + (E << 3) + 4 >> 2], u = 0 | vg(0 | (J = 0 | vg(0 | (e = 0 | vg(0 | (U = 0 | vg(0 | (c = 0 | vg(L & (m ^ N) ^ N | 0, r & (n ^ a) ^ a | 0, 0 | P, 0 | c)), 0 | o(), b ^ i ^ F | 0, 0 | U)), 0 | o(), 0 | h, 0 | e)), 0 | o(), 0 | H, 0 | J)), 0 | (H = 0 | o()), 0 | t, 0 | u), t = 0 | o(), C[B + 56 >> 2] = u, C[B + 56 + 4 >> 2] = t, e = 0 | ZI(s, Y, 28), h = 0 | o(), U = 0 | ZI(s, Y, 34), h = (0 | o()) ^ h, F = 0 | ZI(s, Y, 39), h ^= 0 | o(), h = 0 | vg(0 | (H = 0 | vg(0 | J, 0 | H, s & (y | f) | y & f | 0, Y & (d | G) | d & G | 0)), 0 | o(), U ^ e ^ F | 0, 0 | h), F = 0 | o(), C[B + 24 >> 2] = h, C[B + 24 + 4 >> 2] = F, e = 0 | ZI(u, t, 14), U = 0 | o(), H = 0 | ZI(u, t, 18), U = (0 | o()) ^ U, J = 0 | ZI(u, t, 41), U ^= 0 | o(), b = 0 | C[g + ((i = 5 | D) << 3) >> 2], c = 0 | C[g + (i << 3) + 4 >> 2], P = 0 | C[32416 + (i << 3) >> 2], M = 0 | C[32416 + (i << 3) + 4 >> 2], G = 0 | vg(0 | (M = 0 | vg(0 | (c = 0 | vg(0 | (U = 0 | vg(0 | (a = 0 | vg(u & (L ^ m) ^ m | 0, t & (r ^ n) ^ n | 0, 0 | N, 0 | a)), 0 | o(), H ^ e ^ J | 0, 0 | U)), 0 | o(), 0 | b, 0 | c)), 0 | o(), 0 | P, 0 | M)), 0 | (P = 0 | o()), 0 | f, 0 | G), f = 0 | o(), C[B + 48 >> 2] = G, C[B + 48 + 4 >> 2] = f, c = 0 | ZI(h, F, 28), b = 0 | o(), U = 0 | ZI(h, F, 34), b = (0 | o()) ^ b, J = 0 | ZI(h, F, 39), b ^= 0 | o(), b = 0 | vg(0 | (P = 0 | vg(0 | M, 0 | P, h & (s | y) | s & y | 0, F & (Y | d) | Y & d | 0)), 0 | o(), U ^ c ^ J | 0, 0 | b), J = 0 | o(), C[B + 16 >> 2] = b, C[B + 16 + 4 >> 2] = J, c = 0 | ZI(G, f, 14), U = 0 | o(), P = 0 | ZI(G, f, 18), U = (0 | o()) ^ U, M = 0 | ZI(G, f, 41), U ^= 0 | o(), H = 0 | C[g + ((e = 6 | D) << 3) >> 2], a = 0 | C[g + (e << 3) + 4 >> 2], N = 0 | C[32416 + (e << 3) >> 2], R = 0 | C[32416 + (e << 3) + 4 >> 2], d = 0 | vg(0 | (R = 0 | vg(0 | (a = 0 | vg(0 | (U = 0 | vg(0 | (n = 0 | vg(G & (u ^ L) ^ L | 0, f & (t ^ r) ^ r | 0, 0 | m, 0 | n)), 0 | o(), P ^ c ^ M | 0, 0 | U)), 0 | o(), 0 | H, 0 | a)), 0 | o(), 0 | N, 0 | R)), 0 | (N = 0 | o()), 0 | y, 0 | d), y = 0 | o(), C[B + 40 >> 2] = d, C[B + 40 + 4 >> 2] = y, a = 0 | ZI(b, J, 28), H = 0 | o(), U = 0 | ZI(b, J, 34), H = (0 | o()) ^ H, M = 0 | ZI(b, J, 39), H ^= 0 | o(), H = 0 | vg(0 | (N = 0 | vg(0 | R, 0 | N, b & (h | s) | h & s | 0, J & (F | Y) | F & Y | 0)), 0 | o(), U ^ a ^ M | 0, 0 | H), M = 0 | o(), C[B + 8 >> 2] = H, C[B + 8 + 4 >> 2] = M, a = 0 | ZI(d, y, 14), U = 0 | o(), N = 0 | ZI(d, y, 18), U = (0 | o()) ^ U, R = 0 | ZI(d, y, 41), U ^= 0 | o(), P = 0 | C[g + ((c = 7 | D) << 3) >> 2], n = 0 | C[g + (c << 3) + 4 >> 2], m = 0 | C[32416 + (c << 3) >> 2], x = 0 | C[32416 + (c << 3) + 4 >> 2], Y = 0 | vg(0 | (x = 0 | vg(0 | (n = 0 | vg(0 | (U = 0 | vg(0 | (r = 0 | vg(d & (G ^ u) ^ u | 0, y & (f ^ t) ^ t | 0, 0 | L, 0 | r)), 0 | o(), N ^ a ^ R | 0, 0 | U)), 0 | o(), 0 | P, 0 | n)), 0 | o(), 0 | m, 0 | x)), 0 | (m = 0 | o()), 0 | s, 0 | Y), s = 0 | o(), C[B + 32 >> 2] = Y, C[B + 32 + 4 >> 2] = s, n = 0 | ZI(H, M, 28), P = 0 | o(), U = 0 | ZI(H, M, 34), P = (0 | o()) ^ P, R = 0 | ZI(H, M, 39), P ^= 0 | o(), P = 0 | vg(0 | (m = 0 | vg(0 | x, 0 | m, H & (b | h) | b & h | 0, M & (J | F) | J & F | 0)), 0 | o(), U ^ n ^ R | 0, 0 | P), R = 0 | o(), C[B >> 2] = P, C[B + 4 >> 2] = R, n = 0 | ZI(Y, s, 14), U = 0 | o(), m = 0 | ZI(Y, s, 18), U = (0 | o()) ^ U, x = 0 | ZI(Y, s, 41), U ^= 0 | o(), N = 0 | C[g + ((a = 8 | D) << 3) >> 2], r = 0 | C[g + (a << 3) + 4 >> 2], L = 0 | C[32416 + (a << 3) >> 2], K = 0 | C[32416 + (a << 3) + 4 >> 2], F = 0 | vg(0 | (K = 0 | vg(0 | (r = 0 | vg(0 | (U = 0 | vg(0 | (t = 0 | vg(Y & (d ^ G) ^ G | 0, s & (y ^ f) ^ f | 0, 0 | u, 0 | t)), 0 | o(), m ^ n ^ x | 0, 0 | U)), 0 | o(), 0 | N, 0 | r)), 0 | o(), 0 | L, 0 | K)), 0 | (L = 0 | o()), 0 | h, 0 | F), h = 0 | o(), C[B + 24 >> 2] = F, C[B + 24 + 4 >> 2] = h, r = 0 | ZI(P, R, 28), N = 0 | o(), U = 0 | ZI(P, R, 34), N = (0 | o()) ^ N, x = 0 | ZI(P, R, 39), N ^= 0 | o(), N = 0 | vg(0 | (L = 0 | vg(0 | K, 0 | L, P & (H | b) | H & b | 0, R & (M | J) | M & J | 0)), 0 | o(), U ^ r ^ x | 0, 0 | N), x = 0 | o(), C[B + 56 >> 2] = N, C[B + 56 + 4 >> 2] = x, r = 0 | ZI(F, h, 14), U = 0 | o(), L = 0 | ZI(F, h, 18), U = (0 | o()) ^ U, K = 0 | ZI(F, h, 41), U ^= 0 | o(), m = 0 | C[g + ((n = 9 | D) << 3) >> 2], t = 0 | C[g + (n << 3) + 4 >> 2], u = 0 | C[32416 + (n << 3) >> 2], X = 0 | C[32416 + (n << 3) + 4 >> 2], J = 0 | vg(0 | (X = 0 | vg(0 | (t = 0 | vg(0 | (U = 0 | vg(0 | (f = 0 | vg(F & (Y ^ d) ^ d | 0, h & (s ^ y) ^ y | 0, 0 | G, 0 | f)), 0 | o(), L ^ r ^ K | 0, 0 | U)), 0 | o(), 0 | m, 0 | t)), 0 | o(), 0 | u, 0 | X)), 0 | (u = 0 | o()), 0 | b, 0 | J), b = 0 | o(), C[B + 16 >> 2] = J, C[B + 16 + 4 >> 2] = b, t = 0 | ZI(N, x, 28), m = 0 | o(), U = 0 | ZI(N, x, 34), m = (0 | o()) ^ m, K = 0 | ZI(N, x, 39), m ^= 0 | o(), m = 0 | vg(0 | (u = 0 | vg(0 | X, 0 | u, N & (P | H) | P & H | 0, x & (R | M) | R & M | 0)), 0 | o(), U ^ t ^ K | 0, 0 | m), K = 0 | o(), C[B + 48 >> 2] = m, C[B + 48 + 4 >> 2] = K, t = 0 | ZI(J, b, 14), U = 0 | o(), u = 0 | ZI(J, b, 18), U = (0 | o()) ^ U, X = 0 | ZI(J, b, 41), U ^= 0 | o(), L = 0 | C[g + ((r = 10 | D) << 3) >> 2], f = 0 | C[g + (r << 3) + 4 >> 2], G = 0 | C[32416 + (r << 3) >> 2], p = 0 | C[32416 + (r << 3) + 4 >> 2], M = 0 | vg(0 | (p = 0 | vg(0 | (f = 0 | vg(0 | (U = 0 | vg(0 | (y = 0 | vg(J & (F ^ Y) ^ Y | 0, b & (h ^ s) ^ s | 0, 0 | d, 0 | y)), 0 | o(), u ^ t ^ X | 0, 0 | U)), 0 | o(), 0 | L, 0 | f)), 0 | o(), 0 | G, 0 | p)), 0 | (G = 0 | o()), 0 | H, 0 | M), H = 0 | o(), C[B + 8 >> 2] = M, C[B + 8 + 4 >> 2] = H, f = 0 | ZI(m, K, 28), L = 0 | o(), U = 0 | ZI(m, K, 34), L = (0 | o()) ^ L, X = 0 | ZI(m, K, 39), L ^= 0 | o(), L = 0 | vg(0 | (G = 0 | vg(0 | p, 0 | G, m & (N | P) | N & P | 0, K & (x | R) | x & R | 0)), 0 | o(), U ^ f ^ X | 0, 0 | L), X = 0 | o(), C[B + 40 >> 2] = L, C[B + 40 + 4 >> 2] = X, f = 0 | ZI(M, H, 14), U = 0 | o(), G = 0 | ZI(M, H, 18), U = (0 | o()) ^ U, p = 0 | ZI(M, H, 41), U ^= 0 | o(), u = 0 | C[g + ((t = 11 | D) << 3) >> 2], y = 0 | C[g + (t << 3) + 4 >> 2], d = 0 | C[32416 + (t << 3) >> 2], k = 0 | C[32416 + (t << 3) + 4 >> 2], R = 0 | vg(0 | (k = 0 | vg(0 | (y = 0 | vg(0 | (U = 0 | vg(0 | (s = 0 | vg(M & (J ^ F) ^ F | 0, H & (b ^ h) ^ h | 0, 0 | Y, 0 | s)), 0 | o(), G ^ f ^ p | 0, 0 | U)), 0 | o(), 0 | u, 0 | y)), 0 | o(), 0 | d, 0 | k)), 0 | (d = 0 | o()), 0 | P, 0 | R), P = 0 | o(), C[B >> 2] = R, C[B + 4 >> 2] = P, y = 0 | ZI(L, X, 28), u = 0 | o(), U = 0 | ZI(L, X, 34), u = (0 | o()) ^ u, p = 0 | ZI(L, X, 39), u ^= 0 | o(), u = 0 | vg(0 | (d = 0 | vg(0 | k, 0 | d, L & (m | N) | m & N | 0, X & (K | x) | K & x | 0)), 0 | o(), U ^ y ^ p | 0, 0 | u), p = 0 | o(), C[B + 32 >> 2] = u, C[B + 32 + 4 >> 2] = p, y = 0 | ZI(R, P, 14), U = 0 | o(), d = 0 | ZI(R, P, 18), U = (0 | o()) ^ U, k = 0 | ZI(R, P, 41), U ^= 0 | o(), G = 0 | C[g + ((f = 12 | D) << 3) >> 2], s = 0 | C[g + (f << 3) + 4 >> 2], Y = 0 | C[32416 + (f << 3) >> 2], l = 0 | C[32416 + (f << 3) + 4 >> 2], x = 0 | vg(0 | (l = 0 | vg(0 | (s = 0 | vg(0 | (U = 0 | vg(0 | (h = 0 | vg(R & (M ^ J) ^ J | 0, P & (H ^ b) ^ b | 0, 0 | F, 0 | h)), 0 | o(), d ^ y ^ k | 0, 0 | U)), 0 | o(), 0 | G, 0 | s)), 0 | o(), 0 | Y, 0 | l)), 0 | (Y = 0 | o()), 0 | N, 0 | x), N = 0 | o(), C[B + 56 >> 2] = x, C[B + 56 + 4 >> 2] = N, s = 0 | ZI(u, p, 28), G = 0 | o(), U = 0 | ZI(u, p, 34), G = (0 | o()) ^ G, k = 0 | ZI(u, p, 39), G ^= 0 | o(), G = 0 | vg(0 | (Y = 0 | vg(0 | l, 0 | Y, u & (L | m) | L & m | 0, p & (X | K) | X & K | 0)), 0 | o(), U ^ s ^ k | 0, 0 | G), k = 0 | o(), C[B + 24 >> 2] = G, C[B + 24 + 4 >> 2] = k, s = 0 | ZI(x, N, 14), U = 0 | o(), Y = 0 | ZI(x, N, 18), U = (0 | o()) ^ U, l = 0 | ZI(x, N, 41), U ^= 0 | o(), d = 0 | C[g + ((y = 13 | D) << 3) >> 2], h = 0 | C[g + (y << 3) + 4 >> 2], F = 0 | C[32416 + (y << 3) >> 2], _ = 0 | C[32416 + (y << 3) + 4 >> 2], K = 0 | vg(0 | (_ = 0 | vg(0 | (h = 0 | vg(0 | (U = 0 | vg(0 | (b = 0 | vg(x & (R ^ M) ^ M | 0, N & (P ^ H) ^ H | 0, 0 | J, 0 | b)), 0 | o(), Y ^ s ^ l | 0, 0 | U)), 0 | o(), 0 | d, 0 | h)), 0 | o(), 0 | F, 0 | _)), 0 | (F = 0 | o()), 0 | m, 0 | K), m = 0 | o(), C[B + 48 >> 2] = K, C[B + 48 + 4 >> 2] = m, h = 0 | ZI(G, k, 28), d = 0 | o(), U = 0 | ZI(G, k, 34), d = (0 | o()) ^ d, l = 0 | ZI(G, k, 39), d ^= 0 | o(), d = 0 | vg(0 | (F = 0 | vg(0 | _, 0 | F, G & (u | L) | u & L | 0, k & (p | X) | p & X | 0)), 0 | o(), U ^ h ^ l | 0, 0 | d), l = 0 | o(), C[B + 16 >> 2] = d, C[B + 16 + 4 >> 2] = l, h = 0 | ZI(K, m, 14), U = 0 | o(), F = 0 | ZI(K, m, 18), U = (0 | o()) ^ U, _ = 0 | ZI(K, m, 41), U ^= 0 | o(), Y = 0 | C[g + ((s = 14 | D) << 3) >> 2], b = 0 | C[g + (s << 3) + 4 >> 2], J = 0 | C[32416 + (s << 3) >> 2], v = 0 | C[32416 + (s << 3) + 4 >> 2], X = 0 | vg(0 | (v = 0 | vg(0 | (b = 0 | vg(0 | (U = 0 | vg(0 | (H = 0 | vg(K & (x ^ R) ^ R | 0, m & (N ^ P) ^ P | 0, 0 | M, 0 | H)), 0 | o(), F ^ h ^ _ | 0, 0 | U)), 0 | o(), 0 | Y, 0 | b)), 0 | o(), 0 | J, 0 | v)), 0 | (J = 0 | o()), 0 | L, 0 | X), L = 0 | o(), C[B + 40 >> 2] = X, C[B + 40 + 4 >> 2] = L, b = 0 | ZI(d, l, 28), Y = 0 | o(), U = 0 | ZI(d, l, 34), Y = (0 | o()) ^ Y, _ = 0 | ZI(d, l, 39), Y ^= 0 | o(), Y = 0 | vg(0 | (J = 0 | vg(0 | v, 0 | J, d & (G | u) | G & u | 0, l & (k | p) | k & p | 0)), 0 | o(), U ^ b ^ _ | 0, 0 | Y), _ = 0 | o(), C[B + 8 >> 2] = Y, C[B + 8 + 4 >> 2] = _, b = 0 | ZI(X, L, 14), U = 0 | o(), J = 0 | ZI(X, L, 18), U = (0 | o()) ^ U, v = 0 | ZI(X, L, 41), U ^= 0 | o(), F = 0 | C[g + ((h = 15 | D) << 3) >> 2], H = 0 | C[g + (h << 3) + 4 >> 2], M = 0 | C[32416 + (h << 3) >> 2], S = 0 | C[32416 + (h << 3) + 4 >> 2], p = 0 | vg(0 | (S = 0 | vg(0 | (H = 0 | vg(0 | (U = 0 | vg(0 | (P = 0 | vg(X & (K ^ x) ^ x | 0, L & (m ^ N) ^ N | 0, 0 | R, 0 | P)), 0 | o(), J ^ b ^ v | 0, 0 | U)), 0 | o(), 0 | F, 0 | H)), 0 | o(), 0 | M, 0 | S)), 0 | (M = 0 | o()), 0 | u, 0 | p), u = 0 | o(), C[B + 32 >> 2] = p, C[B + 32 + 4 >> 2] = u, u = 0 | ZI(Y, _, 28), p = 0 | o(), H = 0 | ZI(Y, _, 34), p = (0 | o()) ^ p, F = 0 | ZI(Y, _, 39), p ^= 0 | o(), p = 0 | vg(0 | (k = 0 | vg(0 | S, 0 | M, Y & (d | G) | d & G | 0, _ & (l | k) | l & k | 0)), 0 | o(), H ^ u ^ F | 0, 0 | p), F = 0 | o(), C[B >> 2] = p, C[B + 4 >> 2] = F, 64 == (0 | D)) break;
              d = 0 | ZI(K = 0 | C[g + (s << 3) >> 2], X = 0 | C[g + (s << 3) + 4 >> 2], 19), N = 0 | o(), H = 0 | ZI(K, X, 61), k = 0 | o(), k = 0 | vg((R = 0 | yg(0 | K, 0 | X, 6)) ^ d ^ H | 0, 0 | (k = (0 | o()) ^ N ^ k), 0 | (N = 0 | C[g + (n << 3) >> 2]), 0 | (Y = 0 | C[g + (n << 3) + 4 >> 2])), H = 0 | o(), b = 0 | ZI(d = 0 | C[g + (w << 3) >> 2], R = 0 | C[g + (w << 3) + 4 >> 2], 1), p = 0 | o(), m = 0 | ZI(d, R, 8), P = 0 | o(), J = 0 | yg(0 | d, 0 | R, 7), P = (0 | o()) ^ p ^ P, P = 0 | vg(0 | (p = 0 | vg(0 | k, 0 | H, 0 | C[(p = g + (D << 3) | 0) >> 2], 0 | C[p + 4 >> 2])), 0 | o(), J ^ b ^ m | 0, 0 | P), m = 0 | o(), C[(b = g + ((D = D + 16 | 0) << 3) | 0) >> 2] = P, C[b + 4 >> 2] = m, p = 0 | ZI(b = 0 | C[g + (h << 3) >> 2], J = 0 | C[g + (h << 3) + 4 >> 2], 19), H = 0 | o(), k = 0 | ZI(b, J, 61), l = 0 | o(), F = 0 | yg(0 | b, 0 | J, 6), l = (0 | o()) ^ H ^ l, H = 0 | C[g + (w + 9 << 3) >> 2], L = 0 | C[g + (w + 9 << 3) + 4 >> 2], u = 0 | ZI(_ = 0 | C[g + (w + 1 << 3) >> 2], M = 0 | C[g + (w + 1 << 3) + 4 >> 2], 1), U = 0 | o(), G = 0 | ZI(_, M, 8), S = 0 | o(), v = 0 | yg(0 | _, 0 | M, 7), S = (0 | o()) ^ U ^ S, S = 0 | vg(0 | (l = 0 | vg(0 | (R = 0 | vg(0 | H, 0 | L, 0 | d, 0 | R)), 0 | o(), F ^ p ^ k | 0, 0 | l)), 0 | o(), v ^ u ^ G | 0, 0 | S), G = 0 | o(), C[g + (w + 16 << 3) >> 2] = S, C[g + (w + 16 << 3) + 4 >> 2] = G, u = 0 | ZI(P, m, 19), v = 0 | o(), l = 0 | ZI(P, m, 61), w = 0 | o(), w = 0 | vg((m = 0 | yg(0 | P, 0 | m, 6)) ^ u ^ l | 0, 0 | (w = (0 | o()) ^ v ^ w), 0 | (v = 0 | C[g + (t << 3) >> 2]), 0 | (P = 0 | C[g + (t << 3) + 4 >> 2])), l = 0 | o(), k = 0 | ZI(u = 0 | C[g + (Q << 3) >> 2], m = 0 | C[g + (Q << 3) + 4 >> 2], 1), p = 0 | o(), F = 0 | ZI(u, m, 8), R = 0 | o(), d = 0 | yg(0 | u, 0 | m, 7), R = (0 | o()) ^ p ^ R, R = 0 | vg(0 | (M = 0 | vg(0 | w, 0 | l, 0 | _, 0 | M)), 0 | o(), d ^ k ^ F | 0, 0 | R), F = 0 | o(), C[g + (I + 16 << 3) >> 2] = R, C[g + (I + 16 << 3) + 4 >> 2] = F, k = 0 | ZI(S, G, 19), d = 0 | o(), M = 0 | ZI(S, G, 61), _ = 0 | o(), G = 0 | yg(0 | S, 0 | G, 6), _ = (0 | o()) ^ d ^ _, d = 0 | C[g + (Q + 9 << 3) >> 2], S = 0 | C[g + (Q + 9 << 3) + 4 >> 2], w = 0 | ZI(l = 0 | C[g + (Q + 1 << 3) >> 2], I = 0 | C[g + (Q + 1 << 3) + 4 >> 2], 1), p = 0 | o(), L = 0 | ZI(l, I, 8), H = 0 | o(), U = 0 | yg(0 | l, 0 | I, 7), H = (0 | o()) ^ p ^ H, H = 0 | vg(0 | (_ = 0 | vg(0 | (m = 0 | vg(0 | d, 0 | S, 0 | u, 0 | m)), 0 | o(), G ^ k ^ M | 0, 0 | _)), 0 | o(), U ^ w ^ L | 0, 0 | H), L = 0 | o(), C[g + (Q + 16 << 3) >> 2] = H, C[g + (Q + 16 << 3) + 4 >> 2] = L, w = 0 | ZI(R, F, 19), U = 0 | o(), _ = 0 | ZI(R, F, 61), M = 0 | o(), M = 0 | vg((F = 0 | yg(0 | R, 0 | F, 6)) ^ w ^ _ | 0, 0 | (M = (0 | o()) ^ U ^ M), 0 | (U = 0 | C[g + (y << 3) >> 2]), 0 | (R = 0 | C[g + (y << 3) + 4 >> 2])), _ = 0 | o(), k = 0 | ZI(w = 0 | C[g + (i << 3) >> 2], F = 0 | C[g + (i << 3) + 4 >> 2], 1), G = 0 | o(), m = 0 | ZI(w, F, 8), u = 0 | o(), S = 0 | yg(0 | w, 0 | F, 7), u = (0 | o()) ^ G ^ u, u = 0 | vg(0 | (I = 0 | vg(0 | M, 0 | _, 0 | l, 0 | I)), 0 | o(), S ^ k ^ m | 0, 0 | u), m = 0 | o(), C[g + (E + 16 << 3) >> 2] = u, C[g + (E + 16 << 3) + 4 >> 2] = m, k = 0 | ZI(H, L, 19), S = 0 | o(), I = 0 | ZI(H, L, 61), l = 0 | o(), L = 0 | yg(0 | H, 0 | L, 6), l = (0 | o()) ^ S ^ l, S = 0 | C[g + (i + 9 << 3) >> 2], H = 0 | C[g + (i + 9 << 3) + 4 >> 2], G = 0 | ZI(_ = 0 | C[g + (i + 1 << 3) >> 2], M = 0 | C[g + (i + 1 << 3) + 4 >> 2], 1), d = 0 | o(), p = 0 | ZI(_, M, 8), x = 0 | o(), Q = 0 | yg(0 | _, 0 | M, 7), x = (0 | o()) ^ d ^ x, x = 0 | vg(0 | (l = 0 | vg(0 | (F = 0 | vg(0 | S, 0 | H, 0 | w, 0 | F)), 0 | o(), L ^ k ^ I | 0, 0 | l)), 0 | o(), Q ^ G ^ p | 0, 0 | x), p = 0 | o(), C[g + (i + 16 << 3) >> 2] = x, C[g + (i + 16 << 3) + 4 >> 2] = p, G = 0 | ZI(u, m, 19), Q = 0 | o(), l = 0 | ZI(u, m, 61), I = 0 | o(), I = 0 | vg((m = 0 | yg(0 | u, 0 | m, 6)) ^ G ^ l | 0, (0 | o()) ^ Q ^ I | 0, 0 | b, 0 | J), Q = 0 | o(), m = 0 | ZI(l = 0 | C[g + (c << 3) >> 2], G = 0 | C[g + (c << 3) + 4 >> 2], 1), u = 0 | o(), k = 0 | ZI(l, G, 8), L = 0 | o(), F = 0 | yg(0 | l, 0 | G, 7), L = (0 | o()) ^ u ^ L, L = 0 | vg(0 | (M = 0 | vg(0 | I, 0 | Q, 0 | _, 0 | M)), 0 | o(), F ^ m ^ k | 0, 0 | L), k = 0 | o(), C[g + (e + 16 << 3) >> 2] = L, C[g + (e + 16 << 3) + 4 >> 2] = k, m = 0 | ZI(x, p, 19), F = 0 | o(), M = 0 | ZI(x, p, 61), _ = 0 | o(), p = 0 | yg(0 | x, 0 | p, 6), _ = (0 | o()) ^ F ^ _, F = 0 | C[g + (c + 9 << 3) >> 2], x = 0 | C[g + (c + 9 << 3) + 4 >> 2], u = 0 | ZI(Q = 0 | C[g + (c + 1 << 3) >> 2], I = 0 | C[g + (c + 1 << 3) + 4 >> 2], 1), w = 0 | o(), H = 0 | ZI(Q, I, 8), S = 0 | o(), d = 0 | yg(0 | Q, 0 | I, 7), S = (0 | o()) ^ w ^ S, S = 0 | vg(0 | (_ = 0 | vg(0 | (G = 0 | vg(0 | F, 0 | x, 0 | l, 0 | G)), 0 | o(), p ^ m ^ M | 0, 0 | _)), 0 | o(), d ^ u ^ H | 0, 0 | S), H = 0 | o(), C[g + (c + 16 << 3) >> 2] = S, C[g + (c + 16 << 3) + 4 >> 2] = H, u = 0 | ZI(L, k, 19), d = 0 | o(), _ = 0 | ZI(L, k, 61), M = 0 | o(), M = 0 | vg((k = 0 | yg(0 | L, 0 | k, 6)) ^ u ^ _ | 0, 0 | (M = (0 | o()) ^ d ^ M), 0 | C[g + (a + 9 << 3) >> 2], 0 | C[g + (a + 9 << 3) + 4 >> 2]), _ = 0 | o(), u = 0 | ZI(N, Y, 1), k = 0 | o(), d = 0 | ZI(N, Y, 8), L = 0 | o(), m = 0 | yg(0 | N, 0 | Y, 7), L = k ^ (0 | o()) ^ L, L = 0 | vg(0 | (I = 0 | vg(0 | M, 0 | _, 0 | Q, 0 | I)), 0 | o(), u ^ m ^ d | 0, 0 | L), d = 0 | o(), C[g + (a + 16 << 3) >> 2] = L, C[g + (a + 16 << 3) + 4 >> 2] = d, m = 0 | ZI(S, H, 19), u = 0 | o(), I = 0 | ZI(S, H, 61), Q = 0 | o(), H = 0 | yg(0 | S, 0 | H, 6), Q = (0 | o()) ^ u ^ Q, u = 0 | C[g + (n + 9 << 3) >> 2], S = 0 | C[g + (n + 9 << 3) + 4 >> 2], k = 0 | ZI(_ = 0 | C[g + (n + 1 << 3) >> 2], M = 0 | C[g + (n + 1 << 3) + 4 >> 2], 1), p = 0 | o(), G = 0 | ZI(_, M, 8), l = 0 | o(), x = 0 | yg(0 | _, 0 | M, 7), l = (0 | o()) ^ p ^ l, l = 0 | vg(0 | (Q = 0 | vg(0 | (Y = 0 | vg(0 | u, 0 | S, 0 | N, 0 | Y)), 0 | o(), H ^ m ^ I | 0, 0 | Q)), 0 | o(), x ^ k ^ G | 0, 0 | l), G = 0 | o(), C[g + (n + 16 << 3) >> 2] = l, C[g + (n + 16 << 3) + 4 >> 2] = G, k = 0 | ZI(L, d, 19), x = 0 | o(), Q = 0 | ZI(L, d, 61), I = 0 | o(), I = 0 | vg((d = 0 | yg(0 | L, 0 | d, 6)) ^ k ^ Q | 0, 0 | (I = (0 | o()) ^ x ^ I), 0 | C[g + (r + 9 << 3) >> 2], 0 | C[g + (r + 9 << 3) + 4 >> 2]), Q = 0 | o(), k = 0 | ZI(v, P, 1), d = 0 | o(), x = 0 | ZI(v, P, 8), L = 0 | o(), m = 0 | yg(0 | v, 0 | P, 7), L = d ^ (0 | o()) ^ L, L = 0 | vg(0 | (M = 0 | vg(0 | I, 0 | Q, 0 | _, 0 | M)), 0 | o(), k ^ m ^ x | 0, 0 | L), x = 0 | o(), C[g + (r + 16 << 3) >> 2] = L, C[g + (r + 16 << 3) + 4 >> 2] = x, m = 0 | ZI(l, G, 19), k = 0 | o(), M = 0 | ZI(l, G, 61), _ = 0 | o(), G = 0 | yg(0 | l, 0 | G, 6), _ = (0 | o()) ^ k ^ _, k = 0 | C[g + (t + 9 << 3) >> 2], l = 0 | C[g + (t + 9 << 3) + 4 >> 2], d = 0 | ZI(Q = 0 | C[g + (t + 1 << 3) >> 2], I = 0 | C[g + (t + 1 << 3) + 4 >> 2], 1), H = 0 | o(), Y = 0 | ZI(Q, I, 8), N = 0 | o(), S = 0 | yg(0 | Q, 0 | I, 7), N = (0 | o()) ^ H ^ N, N = 0 | vg(0 | (_ = 0 | vg(0 | (P = 0 | vg(0 | k, 0 | l, 0 | v, 0 | P)), 0 | o(), G ^ m ^ M | 0, 0 | _)), 0 | o(), S ^ d ^ Y | 0, 0 | N), Y = 0 | o(), C[g + (t + 16 << 3) >> 2] = N, C[g + (t + 16 << 3) + 4 >> 2] = Y, d = 0 | ZI(L, x, 19), S = 0 | o(), _ = 0 | ZI(L, x, 61), M = 0 | o(), M = 0 | vg((x = 0 | yg(0 | L, 0 | x, 6)) ^ d ^ _ | 0, 0 | (M = (0 | o()) ^ S ^ M), 0 | C[g + (f + 9 << 3) >> 2], 0 | C[g + (f + 9 << 3) + 4 >> 2]), _ = 0 | o(), d = 0 | ZI(U, R, 1), x = 0 | o(), S = 0 | ZI(U, R, 8), L = 0 | o(), m = 0 | yg(0 | U, 0 | R, 7), L = x ^ (0 | o()) ^ L, L = 0 | vg(0 | (I = 0 | vg(0 | M, 0 | _, 0 | Q, 0 | I)), 0 | o(), d ^ m ^ S | 0, 0 | L), S = 0 | o(), C[g + (f + 16 << 3) >> 2] = L, C[g + (f + 16 << 3) + 4 >> 2] = S, m = 0 | ZI(N, Y, 19), d = 0 | o(), I = 0 | ZI(N, Y, 61), Q = 0 | o(), Y = 0 | yg(0 | N, 0 | Y, 6), Q = (0 | o()) ^ d ^ Q, d = 0 | C[g + (y + 9 << 3) >> 2], N = 0 | C[g + (y + 9 << 3) + 4 >> 2], x = 0 | ZI(_ = 0 | C[g + (y + 1 << 3) >> 2], M = 0 | C[g + (y + 1 << 3) + 4 >> 2], 1), G = 0 | o(), P = 0 | ZI(_, M, 8), v = 0 | o(), M = 0 | yg(0 | _, 0 | M, 7), v = (0 | o()) ^ G ^ v, v = 0 | vg(0 | (Q = 0 | vg(0 | (R = 0 | vg(0 | d, 0 | N, 0 | U, 0 | R)), 0 | o(), Y ^ m ^ I | 0, 0 | Q)), 0 | o(), M ^ x ^ P | 0, 0 | v), P = 0 | o(), C[g + (y + 16 << 3) >> 2] = v, C[g + (y + 16 << 3) + 4 >> 2] = P, x = 0 | ZI(L, S, 19), M = 0 | o(), Q = 0 | ZI(L, S, 61), I = 0 | o(), S = 0 | yg(0 | L, 0 | S, 6), I = (0 | o()) ^ M ^ I, M = 0 | C[g + (s + 9 << 3) >> 2], L = 0 | C[g + (s + 9 << 3) + 4 >> 2], m = 0 | ZI(b, J, 1), Y = 0 | o(), R = 0 | ZI(b, J, 8), U = 0 | o(), N = 0 | yg(0 | b, 0 | J, 7), U = Y ^ (0 | o()) ^ U, U = 0 | vg(0 | (I = 0 | vg(0 | (X = 0 | vg(0 | M, 0 | L, 0 | K, 0 | X)), 0 | o(), S ^ x ^ Q | 0, 0 | I)), 0 | o(), m ^ N ^ R | 0, 0 | U), R = 0 | o(), C[g + (s + 16 << 3) >> 2] = U, C[g + (s + 16 << 3) + 4 >> 2] = R, R = 0 | ZI(v, P, 19), U = 0 | o(), N = 0 | ZI(v, P, 61), m = 0 | o(), P = 0 | yg(0 | v, 0 | P, 6), m = (0 | o()) ^ U ^ m, U = 0 | C[g + (h + 9 << 3) >> 2], v = 0 | C[g + (h + 9 << 3) + 4 >> 2], x = 0 | ZI(I = 0 | C[g + (h + 1 << 3) >> 2], Q = 0 | C[g + (h + 1 << 3) + 4 >> 2], 1), S = 0 | o(), X = 0 | ZI(I, Q, 8), K = 0 | o(), L = 0 | yg(0 | I, 0 | Q, 7), K = (0 | o()) ^ S ^ K, K = 0 | vg(0 | (m = 0 | vg(0 | (J = 0 | vg(0 | U, 0 | v, 0 | b, 0 | J)), 0 | o(), P ^ R ^ N | 0, 0 | m)), 0 | o(), L ^ x ^ X | 0, 0 | K), X = 0 | o(), C[g + (h + 16 << 3) >> 2] = K, C[g + (h + 16 << 3) + 4 >> 2] = X;
            } while (D >>> 0 < 80);

            I = 0;

            do {
              x = B + (I << 3) | 0, x = 0 | vg(0 | C[(X = A + (I << 3) | 0) >> 2], 0 | C[X + 4 >> 2], 0 | C[x >> 2], 0 | C[x + 4 >> 2]), K = 0 | o(), C[X >> 2] = x, C[X + 4 >> 2] = K, I = I + 1 | 0;
            } while (8 != (0 | I));
          }

          function F(A) {
            A |= 0;
            var I,
                g = 0,
                B = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                o = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0;
            I = y, f = y = y + 63 & -64, y = y + 16 | 0;

            do {
              if (A >>> 0 < 245) {
                if (t = A >>> 0 < 11 ? 16 : A + 11 & -8, (n = 0 | C[8679]) >>> (t >>> 3) & 3 | 0) return A = 0 | C[8 + (B = 34756 + ((n >>> (t >>> 3) & 1 ^ 1) + (t >>> 3) << 1 << 2) | 0) >> 2], (0 | (g = 0 | C[A + 8 >> 2])) == (0 | B) ? C[8679] = n & ~(1 << (n >>> (t >>> 3) & 1 ^ 1) + (t >>> 3)) : (C[g + 12 >> 2] = B, C[B + 8 >> 2] = g), u = (n >>> (t >>> 3) & 1 ^ 1) + (t >>> 3) << 3, C[A + 4 >> 2] = 3 | u, C[A + u + 4 >> 2] = 1 | C[A + u + 4 >> 2], y = I, 0 | A + 8;

                if (t >>> 0 > (r = 0 | C[8681]) >>> 0) {
                  if (n >>> (t >>> 3) | 0) return Q = 0 | C[34756 + ((E = ((Q = (((A = n >>> (t >>> 3) << (t >>> 3) & (2 << (t >>> 3) | 0 - (2 << (t >>> 3)))) & 0 - A) - 1 | 0) >>> (((A & 0 - A) - 1 | 0) >>> 12 & 16)) >>> 5 & 8 | ((A & 0 - A) - 1 | 0) >>> 12 & 16 | Q >>> (Q >>> 5 & 8) >>> 2 & 4 | (E = Q >>> (Q >>> 5 & 8) >>> (Q >>> (Q >>> 5 & 8) >>> 2 & 4)) >>> 1 & 2 | E >>> (E >>> 1 & 2) >>> 1 & 1) + (E >>> (E >>> 1 & 2) >>> (E >>> (E >>> 1 & 2) >>> 1 & 1)) | 0) << 1 << 2) + 8 >> 2], (0 | (A = 0 | C[Q + 8 >> 2])) == (34756 + (E << 1 << 2) | 0) ? (C[8679] = n & ~(1 << E), A = n & ~(1 << E)) : (C[A + 12 >> 2] = 34756 + (E << 1 << 2), C[34756 + (E << 1 << 2) + 8 >> 2] = A, A = n), C[Q + 4 >> 2] = 3 | t, C[Q + t + 4 >> 2] = (E << 3) - t | 1, C[Q + (E << 3) >> 2] = (E << 3) - t, 0 | r && (B = 0 | C[8684], A & 1 << (r >>> 3) ? (A = 34756 + (r >>> 3 << 1 << 2) + 8 | 0, g = 0 | C[34756 + (r >>> 3 << 1 << 2) + 8 >> 2]) : (C[8679] = A | 1 << (r >>> 3), A = 34756 + (r >>> 3 << 1 << 2) + 8 | 0, g = 34756 + (r >>> 3 << 1 << 2) | 0), C[A >> 2] = B, C[g + 12 >> 2] = B, C[B + 8 >> 2] = g, C[B + 12 >> 2] = 34756 + (r >>> 3 << 1 << 2)), C[8681] = (E << 3) - t, C[8684] = Q + t, y = I, 0 | Q + 8;

                  if (e = 0 | C[8680]) {
                    for (a = 0 | C[35020 + (((c = ((e & 0 - e) - 1 | 0) >>> (((e & 0 - e) - 1 | 0) >>> 12 & 16)) >>> 5 & 8 | ((e & 0 - e) - 1 | 0) >>> 12 & 16 | c >>> (c >>> 5 & 8) >>> 2 & 4 | (a = c >>> (c >>> 5 & 8) >>> (c >>> (c >>> 5 & 8) >>> 2 & 4)) >>> 1 & 2 | a >>> (a >>> 1 & 2) >>> 1 & 1) + (a >>> (a >>> 1 & 2) >>> (a >>> (a >>> 1 & 2) >>> 1 & 1)) << 2) >> 2], c = (-8 & C[a + 4 >> 2]) - t | 0, g = a; (A = 0 | C[g + 16 >> 2]) || (A = 0 | C[g + 20 >> 2]);) {
                      c = (o = (g = (-8 & C[A + 4 >> 2]) - t | 0) >>> 0 < c >>> 0) ? g : c, g = A, a = o ? A : a;
                    }

                    if ((o = a + t | 0) >>> 0 > a >>> 0) {
                      E = 0 | C[a + 24 >> 2], A = 0 | C[a + 12 >> 2];

                      do {
                        if ((0 | A) == (0 | a)) {
                          if (!(A = 0 | C[(g = a + 20 | 0) >> 2]) && !(A = 0 | C[(g = a + 16 | 0) >> 2])) {
                            g = 0;
                            break;
                          }

                          for (;;) {
                            if (B = 0 | C[(Q = A + 20 | 0) >> 2]) A = B, g = Q;else {
                              if (!(B = 0 | C[(Q = A + 16 | 0) >> 2])) break;
                              A = B, g = Q;
                            }
                          }

                          C[g >> 2] = 0, g = A;
                        } else g = 0 | C[a + 8 >> 2], C[g + 12 >> 2] = A, C[A + 8 >> 2] = g, g = A;
                      } while (0);

                      do {
                        if (0 | E) {
                          if (A = 0 | C[a + 28 >> 2], (0 | a) == (0 | C[35020 + (A << 2) >> 2])) {
                            if (C[35020 + (A << 2) >> 2] = g, !g) {
                              C[8680] = e & ~(1 << A);
                              break;
                            }
                          } else if (C[((0 | C[E + 16 >> 2]) == (0 | a) ? E + 16 | 0 : E + 20 | 0) >> 2] = g, !g) break;

                          C[g + 24 >> 2] = E, 0 | (A = 0 | C[a + 16 >> 2]) && (C[g + 16 >> 2] = A, C[A + 24 >> 2] = g), 0 | (A = 0 | C[a + 20 >> 2]) && (C[g + 20 >> 2] = A, C[A + 24 >> 2] = g);
                        }
                      } while (0);

                      return c >>> 0 < 16 ? (u = c + t | 0, C[a + 4 >> 2] = 3 | u, C[(u = a + u + 4 | 0) >> 2] = 1 | C[u >> 2]) : (C[a + 4 >> 2] = 3 | t, C[o + 4 >> 2] = 1 | c, C[o + c >> 2] = c, 0 | r && (B = 0 | C[8684], 1 << (r >>> 3) & n ? (A = 34756 + (r >>> 3 << 1 << 2) + 8 | 0, g = 0 | C[34756 + (r >>> 3 << 1 << 2) + 8 >> 2]) : (C[8679] = 1 << (r >>> 3) | n, A = 34756 + (r >>> 3 << 1 << 2) + 8 | 0, g = 34756 + (r >>> 3 << 1 << 2) | 0), C[A >> 2] = B, C[g + 12 >> 2] = B, C[B + 8 >> 2] = g, C[B + 12 >> 2] = 34756 + (r >>> 3 << 1 << 2)), C[8681] = c, C[8684] = o), y = I, 0 | a + 8;
                    }
                  }
                }
              } else if (A >>> 0 <= 4294967231) {
                if (t = A + 11 & -8, Q = 0 | C[8680]) {
                  c = (A + 11 | 0) >>> 8 ? t >>> 0 > 16777215 ? 31 : t >>> (7 + (c = 14 - ((520192 + (c = (A + 11 | 0) >>> 8 << ((1048320 + ((A + 11 | 0) >>> 8) | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (1048320 + ((A + 11 | 0) >>> 8) | 0) >>> 16 & 8 | (245760 + (c << ((c + 520192 | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (c << ((c + 520192 | 0) >>> 16 & 4) << ((245760 + (c << ((c + 520192 | 0) >>> 16 & 4)) | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | c << 1 : 0, A = 0 | C[35020 + (c << 2) >> 2];

                  A: do {
                    if (A) for (B = 0 - t | 0, g = 0, o = t << (31 == (0 | c) ? 0 : 25 - (c >>> 1) | 0), e = 0;;) {
                      if ((E = (-8 & C[A + 4 >> 2]) - t | 0) >>> 0 < B >>> 0) {
                        if (!E) {
                          B = 0, g = A, h = 65;
                          break A;
                        }

                        B = E, e = A;
                      }

                      if (g = 0 == (0 | (h = 0 | C[A + 20 >> 2])) | (0 | h) == (0 | (A = 0 | C[A + 16 + (o >>> 31 << 2) >> 2])) ? g : h, !A) {
                        A = e, h = 61;
                        break;
                      }

                      o <<= 1;
                    } else B = 0 - t | 0, g = 0, A = 0, h = 61;
                  } while (0);

                  if (61 == (0 | h)) {
                    if (0 == (0 | g) & 0 == (0 | A)) {
                      if (!(((A = 2 << c) | 0 - A) & Q)) break;
                      g = 0 | C[35020 + (((r = ((A | 0 - A) & Q & 0 - ((A | 0 - A) & Q)) - 1 | 0) >>> (r >>> 12 & 16) >>> 5 & 8 | r >>> 12 & 16 | (A = r >>> (r >>> 12 & 16) >>> (r >>> (r >>> 12 & 16) >>> 5 & 8)) >>> 2 & 4 | A >>> (A >>> 2 & 4) >>> 1 & 2 | (g = A >>> (A >>> 2 & 4) >>> (A >>> (A >>> 2 & 4) >>> 1 & 2)) >>> 1 & 1) + (g >>> (g >>> 1 & 1)) << 2) >> 2], A = 0;
                    }

                    g ? h = 65 : (e = B, o = A);
                  }

                  if (65 == (0 | h)) for (;;) {
                    if (B = (E = (r = (-8 & C[g + 4 >> 2]) - t | 0) >>> 0 < B >>> 0) ? r : B, E = E ? g : A, (A = 0 | C[g + 16 >> 2]) || (A = 0 | C[g + 20 >> 2]), !A) {
                      e = B, o = E;
                      break;
                    }

                    g = A, A = E;
                  }

                  if (0 != (0 | o) && e >>> 0 < ((0 | C[8681]) - t | 0) >>> 0 && (a = o + t | 0) >>> 0 > o >>> 0) {
                    i = 0 | C[o + 24 >> 2], A = 0 | C[o + 12 >> 2];

                    do {
                      if ((0 | A) == (0 | o)) {
                        if (!(A = 0 | C[(g = o + 20 | 0) >> 2]) && !(A = 0 | C[(g = o + 16 | 0) >> 2])) {
                          A = 0;
                          break;
                        }

                        for (;;) {
                          if (B = 0 | C[(E = A + 20 | 0) >> 2]) A = B, g = E;else {
                            if (!(B = 0 | C[(E = A + 16 | 0) >> 2])) break;
                            A = B, g = E;
                          }
                        }

                        C[g >> 2] = 0;
                      } else u = 0 | C[o + 8 >> 2], C[u + 12 >> 2] = A, C[A + 8 >> 2] = u;
                    } while (0);

                    do {
                      if (i) {
                        if (g = 0 | C[o + 28 >> 2], (0 | o) == (0 | C[35020 + (g << 2) >> 2])) {
                          if (C[35020 + (g << 2) >> 2] = A, !A) {
                            C[8680] = Q & ~(1 << g), Q &= ~(1 << g);
                            break;
                          }
                        } else if (C[((0 | C[i + 16 >> 2]) == (0 | o) ? i + 16 | 0 : i + 20 | 0) >> 2] = A, !A) break;

                        C[A + 24 >> 2] = i, 0 | (g = 0 | C[o + 16 >> 2]) && (C[A + 16 >> 2] = g, C[g + 24 >> 2] = A), (g = 0 | C[o + 20 >> 2]) && (C[A + 20 >> 2] = g, C[g + 24 >> 2] = A);
                      }
                    } while (0);

                    A: do {
                      if (e >>> 0 < 16) u = e + t | 0, C[o + 4 >> 2] = 3 | u, C[(u = o + u + 4 | 0) >> 2] = 1 | C[u >> 2];else {
                        if (C[o + 4 >> 2] = 3 | t, C[a + 4 >> 2] = 1 | e, C[a + e >> 2] = e, B = e >>> 3, e >>> 0 < 256) {
                          (A = 0 | C[8679]) & 1 << B ? (A = 34756 + (B << 1 << 2) + 8 | 0, g = 0 | C[34756 + (B << 1 << 2) + 8 >> 2]) : (C[8679] = A | 1 << B, A = 34756 + (B << 1 << 2) + 8 | 0, g = 34756 + (B << 1 << 2) | 0), C[A >> 2] = a, C[g + 12 >> 2] = a, C[a + 8 >> 2] = g, C[a + 12 >> 2] = 34756 + (B << 1 << 2);
                          break;
                        }

                        if (A = 35020 + ((B = (A = e >>> 8) ? e >>> 0 > 16777215 ? 31 : e >>> (7 + (B = 14 - ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (A + 1048320 | 0) >>> 16 & 8 | (245760 + (B = A << ((A + 1048320 | 0) >>> 16 & 8) << ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (B << ((B + 245760 | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | B << 1 : 0) << 2) | 0, C[a + 28 >> 2] = B, C[a + 16 + 4 >> 2] = 0, C[a + 16 >> 2] = 0, !(Q & (g = 1 << B))) {
                          C[8680] = Q | g, C[A >> 2] = a, C[a + 24 >> 2] = A, C[a + 12 >> 2] = a, C[a + 8 >> 2] = a;
                          break;
                        }

                        A = 0 | C[A >> 2];

                        I: do {
                          if ((-8 & C[A + 4 >> 2] | 0) != (0 | e)) {
                            for (Q = e << (31 == (0 | B) ? 0 : 25 - (B >>> 1) | 0); g = 0 | C[(B = A + 16 + (Q >>> 31 << 2) | 0) >> 2];) {
                              if ((-8 & C[g + 4 >> 2] | 0) == (0 | e)) {
                                A = g;
                                break I;
                              }

                              Q <<= 1, A = g;
                            }

                            C[B >> 2] = a, C[a + 24 >> 2] = A, C[a + 12 >> 2] = a, C[a + 8 >> 2] = a;
                            break A;
                          }
                        } while (0);

                        u = 0 | C[(p = A + 8 | 0) >> 2], C[u + 12 >> 2] = a, C[p >> 2] = a, C[a + 8 >> 2] = u, C[a + 12 >> 2] = A, C[a + 24 >> 2] = 0;
                      }
                    } while (0);

                    return y = I, 0 | o + 8;
                  }
                }
              } else t = -1;
            } while (0);

            if ((B = 0 | C[8681]) >>> 0 >= t >>> 0) return g = B - t | 0, A = 0 | C[8684], g >>> 0 > 15 ? (u = A + t | 0, C[8684] = u, C[8681] = g, C[u + 4 >> 2] = 1 | g, C[A + B >> 2] = g, C[A + 4 >> 2] = 3 | t) : (C[8681] = 0, C[8684] = 0, C[A + 4 >> 2] = 3 | B, C[A + B + 4 >> 2] = 1 | C[A + B + 4 >> 2]), y = I, 0 | A + 8;
            if ((E = 0 | C[8682]) >>> 0 > t >>> 0) return F = E - t | 0, C[8682] = F, p = (u = 0 | C[8685]) + t | 0, C[8685] = p, C[p + 4 >> 2] = 1 | F, C[u + 4 >> 2] = 3 | t, y = I, 0 | u + 8;
            if (0 | C[8797] ? A = 0 | C[8799] : (C[8799] = 4096, C[8798] = 4096, C[8800] = -1, C[8801] = -1, C[8802] = 0, C[8790] = 0, C[8797] = -16 & f ^ 1431655768, A = 4096), e = t + 48 | 0, ((a = A + (o = t + 47 | 0) | 0) & (c = 0 - A | 0)) >>> 0 <= t >>> 0) return y = I, 0;
            if (0 | (A = 0 | C[8789]) && (((f = 0 | C[8787]) + (a & c) | 0) >>> 0 <= f >>> 0 || (f + (a & c) | 0) >>> 0 > A >>> 0)) return y = I, 0;

            A: do {
              if (4 & C[8790]) A = 0, h = 143;else {
                g = 0 | C[8685];

                I: do {
                  if (g) {
                    for (B = 35164; !((A = 0 | C[B >> 2]) >>> 0 <= g >>> 0 && (A + (0 | C[(s = B + 4 | 0) >> 2]) | 0) >>> 0 > g >>> 0);) {
                      if (!(A = 0 | C[B + 8 >> 2])) {
                        h = 128;
                        break I;
                      }

                      B = A;
                    }

                    if ((a - E & c) >>> 0 < 2147483647) {
                      if ((0 | (A = 0 | bI(a - E & c))) == ((0 | C[B >> 2]) + (0 | C[s >> 2]) | 0)) {
                        if (-1 != (0 | A)) {
                          e = A, i = a - E & c, h = 145;
                          break A;
                        }

                        A = a - E & c;
                      } else Q = A, B = a - E & c, h = 136;
                    } else A = 0;
                  } else h = 128;
                } while (0);

                do {
                  if (128 == (0 | h)) if (-1 != (0 | (g = 0 | bI(0))) && (i = (0 == ((i = 0 | C[8798]) - 1 & g | 0) ? 0 : (i + -1 + g & 0 - i) - g | 0) + (a & c) | 0, w = 0 | C[8787], i >>> 0 > t >>> 0 & i >>> 0 < 2147483647)) {
                    if (0 | (s = 0 | C[8789]) && (i + w | 0) >>> 0 <= w >>> 0 | (i + w | 0) >>> 0 > s >>> 0) {
                      A = 0;
                      break;
                    }

                    if ((0 | (A = 0 | bI(i))) == (0 | g)) {
                      e = g, h = 145;
                      break A;
                    }

                    Q = A, B = i, h = 136;
                  } else A = 0;
                } while (0);

                do {
                  if (136 == (0 | h)) {
                    if (g = 0 - B | 0, !(e >>> 0 > B >>> 0 & B >>> 0 < 2147483647 & -1 != (0 | Q))) {
                      if (-1 == (0 | Q)) {
                        A = 0;
                        break;
                      }

                      e = Q, i = B, h = 145;
                      break A;
                    }

                    if ((A = o - B + (A = 0 | C[8799]) & 0 - A) >>> 0 >= 2147483647) {
                      e = Q, i = B, h = 145;
                      break A;
                    }

                    if (-1 == (0 | bI(A))) {
                      bI(g), A = 0;
                      break;
                    }

                    e = Q, i = A + B | 0, h = 145;
                    break A;
                  }
                } while (0);

                C[8790] = 4 | C[8790], h = 143;
              }
            } while (0);

            if (143 == (0 | h) && (a & c) >>> 0 < 2147483647 && !(-1 == (0 | (D = 0 | bI(a & c))) | 1 ^ (p = ((F = 0 | bI(0)) - D | 0) >>> 0 > (t + 40 | 0) >>> 0) | D >>> 0 < F >>> 0 & -1 != (0 | D) & -1 != (0 | F) ^ 1) && (e = D, i = p ? F - D | 0 : A, h = 145), 145 == (0 | h)) {
              A = (0 | C[8787]) + i | 0, C[8787] = A, A >>> 0 > (0 | C[8788]) >>> 0 && (C[8788] = A), c = 0 | C[8685];

              A: do {
                if (c) {
                  for (E = 35164;;) {
                    if ((0 | e) == ((A = 0 | C[E >> 2]) + (g = 0 | C[(Q = E + 4 | 0) >> 2]) | 0)) {
                      h = 154;
                      break;
                    }

                    if (!(B = 0 | C[E + 8 >> 2])) break;
                    E = B;
                  }

                  if (154 == (0 | h) && 0 == (8 & C[E + 12 >> 2] | 0) && e >>> 0 > c >>> 0 & A >>> 0 <= c >>> 0) {
                    C[Q >> 2] = g + i, u = (0 | C[8682]) + i | 0, p = 0 == (c + 8 & 7 | 0) ? 0 : 0 - (c + 8) & 7, C[8685] = c + p, C[8682] = u - p, C[c + p + 4 >> 2] = u - p | 1, C[c + u + 4 >> 2] = 40, C[8686] = C[8801];
                    break;
                  }

                  for (e >>> 0 < (0 | C[8683]) >>> 0 && (C[8683] = e), B = e + i | 0, g = 35164;;) {
                    if ((0 | C[g >> 2]) == (0 | B)) {
                      h = 162;
                      break;
                    }

                    if (!(A = 0 | C[g + 8 >> 2])) break;
                    g = A;
                  }

                  if (162 == (0 | h) && 0 == (8 & C[g + 12 >> 2] | 0)) {
                    C[g >> 2] = e, C[(n = g + 4 | 0) >> 2] = (0 | C[n >> 2]) + i, a = (n = e + (0 == (7 & (n = e + 8 | 0) | 0) ? 0 : 0 - n & 7) | 0) + t | 0, o = (A = B + (0 == (B + 8 & 7 | 0) ? 0 : 0 - (B + 8) & 7) | 0) - n - t | 0, C[n + 4 >> 2] = 3 | t;

                    I: do {
                      if ((0 | c) == (0 | A)) u = (0 | C[8682]) + o | 0, C[8682] = u, C[8685] = a, C[a + 4 >> 2] = 1 | u;else {
                        if ((0 | C[8684]) == (0 | A)) {
                          u = (0 | C[8681]) + o | 0, C[8681] = u, C[8684] = a, C[a + 4 >> 2] = 1 | u, C[a + u >> 2] = u;
                          break;
                        }

                        if (1 == (3 & (e = 0 | C[A + 4 >> 2]) | 0)) {
                          g: do {
                            if (e >>> 0 < 256) {
                              if (g = 0 | C[A + 8 >> 2], (0 | (B = 0 | C[A + 12 >> 2])) == (0 | g)) {
                                C[8679] = C[8679] & ~(1 << (e >>> 3));
                                break;
                              }

                              C[g + 12 >> 2] = B, C[B + 8 >> 2] = g;
                              break;
                            }

                            i = 0 | C[A + 24 >> 2], g = 0 | C[A + 12 >> 2];

                            do {
                              if ((0 | g) == (0 | A)) {
                                if (g = 0 | C[A + 16 + 4 >> 2]) B = A + 16 + 4 | 0;else {
                                  if (!(g = 0 | C[A + 16 >> 2])) {
                                    g = 0;
                                    break;
                                  }

                                  B = A + 16 | 0;
                                }

                                for (;;) {
                                  if (Q = 0 | C[(E = g + 20 | 0) >> 2]) g = Q, B = E;else {
                                    if (!(Q = 0 | C[(E = g + 16 | 0) >> 2])) break;
                                    g = Q, B = E;
                                  }
                                }

                                C[B >> 2] = 0;
                              } else u = 0 | C[A + 8 >> 2], C[u + 12 >> 2] = g, C[g + 8 >> 2] = u;
                            } while (0);

                            if (!i) break;
                            B = 0 | C[A + 28 >> 2];

                            do {
                              if ((0 | C[35020 + (B << 2) >> 2]) == (0 | A)) {
                                if (C[35020 + (B << 2) >> 2] = g, 0 | g) break;
                                C[8680] = C[8680] & ~(1 << B);
                                break g;
                              }

                              if (C[((0 | C[i + 16 >> 2]) == (0 | A) ? i + 16 | 0 : i + 20 | 0) >> 2] = g, !g) break g;
                            } while (0);

                            if (C[g + 24 >> 2] = i, 0 | (B = 0 | C[A + 16 >> 2]) && (C[g + 16 >> 2] = B, C[B + 24 >> 2] = g), !(B = 0 | C[A + 16 + 4 >> 2])) break;
                            C[g + 20 >> 2] = B, C[B + 24 >> 2] = g;
                          } while (0);

                          A = A + (-8 & e) | 0, E = (-8 & e) + o | 0;
                        } else E = o;

                        if (C[(B = A + 4 | 0) >> 2] = -2 & C[B >> 2], C[a + 4 >> 2] = 1 | E, C[a + E >> 2] = E, B = E >>> 3, E >>> 0 < 256) {
                          (A = 0 | C[8679]) & 1 << B ? (A = 34756 + (B << 1 << 2) + 8 | 0, g = 0 | C[34756 + (B << 1 << 2) + 8 >> 2]) : (C[8679] = A | 1 << B, A = 34756 + (B << 1 << 2) + 8 | 0, g = 34756 + (B << 1 << 2) | 0), C[A >> 2] = a, C[g + 12 >> 2] = a, C[a + 8 >> 2] = g, C[a + 12 >> 2] = 34756 + (B << 1 << 2);
                          break;
                        }

                        A = E >>> 8;

                        do {
                          if (A) {
                            if (E >>> 0 > 16777215) {
                              Q = 31;
                              break;
                            }

                            Q = E >>> (7 + (Q = 14 - ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (A + 1048320 | 0) >>> 16 & 8 | (245760 + (Q = A << ((A + 1048320 | 0) >>> 16 & 8) << ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (Q << ((Q + 245760 | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | Q << 1;
                          } else Q = 0;
                        } while (0);

                        if (g = 35020 + (Q << 2) | 0, C[a + 28 >> 2] = Q, C[a + 16 + 4 >> 2] = 0, C[a + 16 >> 2] = 0, !((A = 0 | C[8680]) & (B = 1 << Q))) {
                          C[8680] = A | B, C[g >> 2] = a, C[a + 24 >> 2] = g, C[a + 12 >> 2] = a, C[a + 8 >> 2] = a;
                          break;
                        }

                        A = 0 | C[g >> 2];

                        g: do {
                          if ((-8 & C[A + 4 >> 2] | 0) != (0 | E)) {
                            for (Q = E << (31 == (0 | Q) ? 0 : 25 - (Q >>> 1) | 0); g = 0 | C[(B = A + 16 + (Q >>> 31 << 2) | 0) >> 2];) {
                              if ((-8 & C[g + 4 >> 2] | 0) == (0 | E)) {
                                A = g;
                                break g;
                              }

                              Q <<= 1, A = g;
                            }

                            C[B >> 2] = a, C[a + 24 >> 2] = A, C[a + 12 >> 2] = a, C[a + 8 >> 2] = a;
                            break I;
                          }
                        } while (0);

                        u = 0 | C[(p = A + 8 | 0) >> 2], C[u + 12 >> 2] = a, C[p >> 2] = a, C[a + 8 >> 2] = u, C[a + 12 >> 2] = A, C[a + 24 >> 2] = 0;
                      }
                    } while (0);

                    return y = I, 0 | n + 8;
                  }

                  for (g = 35164; !((A = 0 | C[g >> 2]) >>> 0 <= c >>> 0 && (u = A + (0 | C[g + 4 >> 2]) | 0) >>> 0 > c >>> 0);) {
                    g = 0 | C[g + 8 >> 2];
                  }

                  E = (E = u + -47 + (0 == (u + -47 + 8 & 7 | 0) ? 0 : 0 - (u + -47 + 8) & 7) | 0) >>> 0 < (c + 16 | 0) >>> 0 ? c : E, A = i + -40 | 0, p = e + (F = 0 == (7 & (F = e + 8 | 0) | 0) ? 0 : 0 - F & 7) | 0, C[8685] = p, C[8682] = A - F, C[p + 4 >> 2] = A - F | 1, C[e + A + 4 >> 2] = 40, C[8686] = C[8801], C[E + 4 >> 2] = 27, C[E + 8 >> 2] = C[8791], C[E + 8 + 4 >> 2] = C[8792], C[E + 8 + 8 >> 2] = C[8793], C[E + 8 + 12 >> 2] = C[8794], C[8791] = e, C[8792] = i, C[8794] = 0, C[8793] = E + 8, A = E + 24 | 0;

                  do {
                    p = A, C[(A = A + 4 | 0) >> 2] = 7;
                  } while ((p + 8 | 0) >>> 0 < u >>> 0);

                  if ((0 | E) != (0 | c)) {
                    if (C[E + 4 >> 2] = -2 & C[E + 4 >> 2], C[c + 4 >> 2] = E - c | 1, C[E >> 2] = E - c, (E - c | 0) >>> 0 < 256) {
                      B = 34756 + ((E - c | 0) >>> 3 << 1 << 2) | 0, (A = 0 | C[8679]) & 1 << ((E - c | 0) >>> 3) ? (A = B + 8 | 0, g = 0 | C[B + 8 >> 2]) : (C[8679] = A | 1 << ((E - c | 0) >>> 3), A = B + 8 | 0, g = B), C[A >> 2] = c, C[g + 12 >> 2] = c, C[c + 8 >> 2] = g, C[c + 12 >> 2] = B;
                      break;
                    }

                    if (g = 35020 + ((Q = (E - c | 0) >>> 8 ? (E - c | 0) >>> 0 > 16777215 ? 31 : (E - c | 0) >>> (7 + (Q = 14 - ((520192 + (Q = (E - c | 0) >>> 8 << ((1048320 + ((E - c | 0) >>> 8) | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (1048320 + ((E - c | 0) >>> 8) | 0) >>> 16 & 8 | (245760 + (Q << ((Q + 520192 | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (Q << ((Q + 520192 | 0) >>> 16 & 4) << ((245760 + (Q << ((Q + 520192 | 0) >>> 16 & 4)) | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | Q << 1 : 0) << 2) | 0, C[c + 28 >> 2] = Q, C[c + 20 >> 2] = 0, C[c + 16 >> 2] = 0, !((A = 0 | C[8680]) & (B = 1 << Q))) {
                      C[8680] = A | B, C[g >> 2] = c, C[c + 24 >> 2] = g, C[c + 12 >> 2] = c, C[c + 8 >> 2] = c;
                      break;
                    }

                    A = 0 | C[g >> 2];

                    I: do {
                      if ((-8 & C[A + 4 >> 2] | 0) != (E - c | 0)) {
                        for (Q = E - c << (31 == (0 | Q) ? 0 : 25 - (Q >>> 1) | 0); g = 0 | C[(B = A + 16 + (Q >>> 31 << 2) | 0) >> 2];) {
                          if ((-8 & C[g + 4 >> 2] | 0) == (E - c | 0)) {
                            A = g;
                            break I;
                          }

                          Q <<= 1, A = g;
                        }

                        C[B >> 2] = c, C[c + 24 >> 2] = A, C[c + 12 >> 2] = c, C[c + 8 >> 2] = c;
                        break A;
                      }
                    } while (0);

                    u = 0 | C[(p = A + 8 | 0) >> 2], C[u + 12 >> 2] = c, C[p >> 2] = c, C[c + 8 >> 2] = u, C[c + 12 >> 2] = A, C[c + 24 >> 2] = 0;
                  }
                } else 0 == (0 | (u = 0 | C[8683])) | e >>> 0 < u >>> 0 && (C[8683] = e), C[8791] = e, C[8792] = i, C[8794] = 0, C[8688] = C[8797], C[8687] = -1, C[8692] = 34756, C[8691] = 34756, C[8694] = 34764, C[8693] = 34764, C[8696] = 34772, C[8695] = 34772, C[8698] = 34780, C[8697] = 34780, C[8700] = 34788, C[8699] = 34788, C[8702] = 34796, C[8701] = 34796, C[8704] = 34804, C[8703] = 34804, C[8706] = 34812, C[8705] = 34812, C[8708] = 34820, C[8707] = 34820, C[8710] = 34828, C[8709] = 34828, C[8712] = 34836, C[8711] = 34836, C[8714] = 34844, C[8713] = 34844, C[8716] = 34852, C[8715] = 34852, C[8718] = 34860, C[8717] = 34860, C[8720] = 34868, C[8719] = 34868, C[8722] = 34876, C[8721] = 34876, C[8724] = 34884, C[8723] = 34884, C[8726] = 34892, C[8725] = 34892, C[8728] = 34900, C[8727] = 34900, C[8730] = 34908, C[8729] = 34908, C[8732] = 34916, C[8731] = 34916, C[8734] = 34924, C[8733] = 34924, C[8736] = 34932, C[8735] = 34932, C[8738] = 34940, C[8737] = 34940, C[8740] = 34948, C[8739] = 34948, C[8742] = 34956, C[8741] = 34956, C[8744] = 34964, C[8743] = 34964, C[8746] = 34972, C[8745] = 34972, C[8748] = 34980, C[8747] = 34980, C[8750] = 34988, C[8749] = 34988, C[8752] = 34996, C[8751] = 34996, C[8754] = 35004, C[8753] = 35004, u = i + -40 | 0, p = e + (F = 0 == (7 & (F = e + 8 | 0) | 0) ? 0 : 0 - F & 7) | 0, C[8685] = p, C[8682] = u - F, C[p + 4 >> 2] = u - F | 1, C[e + u + 4 >> 2] = 40, C[8686] = C[8801];
              } while (0);

              if ((A = 0 | C[8682]) >>> 0 > t >>> 0) return F = A - t | 0, C[8682] = F, p = (u = 0 | C[8685]) + t | 0, C[8685] = p, C[p + 4 >> 2] = 1 | F, C[u + 4 >> 2] = 3 | t, y = I, 0 | u + 8;
            }

            return C[8678] = 48, y = I, 0;
          }

          function p(A) {
            var I,
                g,
                C,
                Q,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0,
                m = 0,
                L = 0,
                x = 0,
                K = 0,
                X = 0,
                j = 0,
                T = 0,
                q = 0,
                V = 0,
                z = 0,
                W = 0,
                O = 0,
                Z = 0,
                $ = 0,
                AA = 0,
                IA = 0,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0,
                tA = 0,
                fA = 0,
                wA = 0,
                yA = 0;
            j = 0 | Bg(0 | B[(A |= 0) >> 0], 0 | B[A + 1 >> 0], 0 | B[A + 2 >> 0]), o(), V = 0 | yg(0 | (V = 0 | kI(A + 2 | 0)), 0 | o(), 5), o(), J = 0 | yg(0 | (J = 0 | Bg(0 | B[A + 5 >> 0], 0 | B[A + 6 >> 0], 0 | B[A + 7 >> 0])), 0 | o(), 2), o(), y = 0 | yg(0 | (y = 0 | kI(A + 7 | 0)), 0 | o(), 7), o(), T = 0 | yg(0 | (T = 0 | kI(A + 10 | 0)), 0 | o(), 4), o(), Z = 0 | yg(0 | (Z = 0 | Bg(0 | B[A + 13 >> 0], 0 | B[A + 14 >> 0], 0 | B[A + 15 >> 0])), 0 | o(), 1), o(), l = 0 | yg(0 | (l = 0 | kI(A + 15 | 0)), 0 | o(), 6), o(), oA = 0 | yg(0 | (oA = 0 | Bg(0 | B[A + 18 >> 0], 0 | B[A + 19 >> 0], 0 | B[A + 20 >> 0])), 0 | o(), 3), o(), rA = 0 | Bg(0 | B[A + 21 >> 0], 0 | B[A + 22 >> 0], 0 | B[A + 23 >> 0]), o(), EA = 0 | yg(0 | (EA = 0 | kI(A + 23 | 0)), 0 | o(), 5), o(), nA = 0 | yg(0 | (nA = 0 | Bg(0 | B[A + 26 >> 0], 0 | B[A + 27 >> 0], 0 | B[A + 28 >> 0])), 0 | o(), 2), o(), gA = 0 | yg(0 | (gA = 0 | kI(A + 28 | 0)), 0 | o(), 7), o(), wA = 0 | yg(0 | (wA = 0 | kI(A + 31 | 0)), 0 | o(), 4), o(), Y = 0 | yg(0 | (Y = 0 | Bg(0 | B[A + 34 >> 0], 0 | B[A + 35 >> 0], 0 | B[A + 36 >> 0])), 0 | o(), 1), o(), K = 0 | yg(0 | (K = 0 | kI(A + 36 | 0)), 0 | o(), 6), o(), p = 0 | yg(0 | (p = 0 | Bg(0 | B[A + 39 >> 0], 0 | B[A + 40 >> 0], 0 | B[A + 41 >> 0])), 0 | o(), 3), o(), e = 0 | Bg(0 | B[A + 42 >> 0], 0 | B[A + 43 >> 0], 0 | B[A + 44 >> 0]), o(), L = 0 | yg(0 | (L = 0 | kI(A + 44 | 0)), 0 | o(), 5), o(), CA = 0 | yg(0 | (CA = 0 | Bg(0 | B[A + 47 >> 0], 0 | B[A + 48 >> 0], 0 | B[A + 49 >> 0])), 0 | o(), 2), o(), yA = 0 | yg(0 | (yA = 0 | kI(A + 49 | 0)), 0 | o(), 7), o(), f = 0 | yg(0 | (f = 0 | kI(A + 52 | 0)), 0 | o(), 4), o(), G = 0 | yg(0 | (G = 0 | Bg(0 | B[A + 55 >> 0], 0 | B[A + 56 >> 0], 0 | B[A + 57 >> 0])), 0 | o(), 1), o(), U = 0 | yg(0 | (U = 0 | kI(A + 57 | 0)), 0 | o(), 6), o(), r = 0 | Qg(0 | (q = 0 | yg(0 | (q = 0 | kI(A + 60 | 0)), 0 | o(), 3)), 0 | (c = 0 | o()), 666643, 0), F = 0 | o(), aA = 0 | Qg(0 | q, 0 | c, 470296, 0), u = 0 | o(), M = 0 | Qg(0 | q, 0 | c, 654183, 0), a = 0 | o(), _ = 0 | Qg(0 | q, 0 | c, -997805, -1), t = 0 | o(), p = 0 | vg(0 | (E = 0 | Qg(0 | q, 0 | c, 136657, 0)), 0 | o(), 2097151 & p | 0, 0), E = 0 | o(), e = 0 | vg(0 | (c = 0 | Qg(0 | q, 0 | c, -683901, -1)), 0 | o(), 2097151 & e | 0, 0), c = 0 | o(), q = 0 | Qg(2097151 & U | 0, 0, 666643, 0), x = 0 | o(), k = 0 | Qg(2097151 & U | 0, 0, 470296, 0), IA = 0 | o(), v = 0 | Qg(2097151 & U | 0, 0, 654183, 0), i = 0 | o(), W = 0 | Qg(2097151 & U | 0, 0, -997805, -1), z = 0 | o(), X = 0 | Qg(2097151 & U | 0, 0, 136657, 0), D = 0 | o(), U = 0 | vg(0 | p, 0 | E, 0 | (U = 0 | Qg(2097151 & U | 0, 0, -683901, -1)), 0 | o()), E = 0 | o(), p = 0 | Qg(2097151 & G | 0, 0, 666643, 0), O = 0 | o(), d = 0 | Qg(2097151 & G | 0, 0, 470296, 0), BA = 0 | o(), m = 0 | Qg(2097151 & G | 0, 0, 654183, 0), n = 0 | o(), tA = 0 | Qg(2097151 & G | 0, 0, -997805, -1), cA = 0 | o(), AA = 0 | Qg(2097151 & G | 0, 0, 136657, 0), b = 0 | o(), D = 0 | vg(0 | (t = 0 | vg(0 | (K = 0 | vg(0 | (G = 0 | Qg(2097151 & G | 0, 0, -683901, -1)), 0 | o(), 2097151 & K | 0, 0)), 0 | o(), 0 | _, 0 | t)), 0 | o(), 0 | X, 0 | D), X = 0 | o(), t = 0 | Qg(2097151 & f | 0, 0, 666643, 0), _ = 0 | o(), K = 0 | Qg(2097151 & f | 0, 0, 470296, 0), G = 0 | o(), s = 0 | Qg(2097151 & f | 0, 0, 654183, 0), $ = 0 | o(), P = 0 | Qg(2097151 & f | 0, 0, -997805, -1), R = 0 | o(), Q = 0 | Qg(2097151 & f | 0, 0, 136657, 0), fA = 0 | o(), f = 0 | Qg(2097151 & f | 0, 0, -683901, -1), w = 0 | o(), h = 0 | Qg(2097151 & yA | 0, 0, 666643, 0), S = 0 | o(), iA = 0 | Qg(2097151 & yA | 0, 0, 470296, 0), eA = 0 | o(), g = 0 | Qg(2097151 & yA | 0, 0, 654183, 0), QA = 0 | o(), C = 0 | Qg(2097151 & yA | 0, 0, -997805, -1), N = 0 | o(), I = 0 | Qg(2097151 & yA | 0, 0, 136657, 0), H = 0 | o(), i = 0 | vg(0 | (u = 0 | vg(0 | (cA = 0 | vg(0 | (fA = 0 | vg(0 | (wA = 0 | vg(0 | (yA = 0 | Qg(2097151 & yA | 0, 0, -683901, -1)), 0 | o(), 2097151 & wA | 0, 0)), 0 | o(), 0 | Q, 0 | fA)), 0 | o(), 0 | tA, 0 | cA)), 0 | o(), 0 | aA, 0 | u)), 0 | o(), 0 | v, 0 | i), v = 0 | o(), l = 0 | vg(0 | (u = 0 | Qg(2097151 & CA | 0, 0, 666643, 0)), 0 | o(), 2097151 & l | 0, 0), u = 0 | o(), aA = 0 | Qg(2097151 & CA | 0, 0, 470296, 0), cA = 0 | o(), _ = 0 | vg(0 | (eA = 0 | vg(0 | (rA = 0 | vg(0 | (tA = 0 | Qg(2097151 & CA | 0, 0, 654183, 0)), 0 | o(), 2097151 & rA | 0, 0)), 0 | o(), 0 | iA, 0 | eA)), 0 | o(), 0 | t, 0 | _), t = 0 | o(), eA = 0 | Qg(2097151 & CA | 0, 0, -997805, -1), iA = 0 | o(), x = 0 | vg(0 | (BA = 0 | vg(0 | ($ = 0 | vg(0 | (N = 0 | vg(0 | (nA = 0 | vg(0 | (rA = 0 | Qg(2097151 & CA | 0, 0, 136657, 0)), 0 | o(), 2097151 & nA | 0, 0)), 0 | o(), 0 | C, 0 | N)), 0 | o(), 0 | s, 0 | $)), 0 | o(), 0 | d, 0 | BA)), 0 | o(), 0 | q, 0 | x), q = 0 | o(), CA = 0 | Qg(2097151 & CA | 0, 0, -683901, -1), BA = 0 | o(), s = 0 | yg(0 | (d = 0 | vg(0 | l, 0 | u, 1048576, 0)), 0 | ($ = 0 | o()), 21), N = 0 | o(), N = 0 | vg(0 | (S = 0 | vg(0 | (oA = 0 | vg(0 | aA, 0 | cA, 2097151 & oA | 0, 0)), 0 | o(), 0 | h, 0 | S)), 0 | o(), 0 | s, 0 | N), s = 0 | o(), $ = 0 | Ug(0 | l, 0 | u, -2097152 & d | 0, 2047 & $ | 0), d = 0 | o(), S = 0 | yg(0 | (u = 0 | vg(0 | _, 0 | t, 1048576, 0)), 0 | (l = 0 | o()), 21), h = 0 | o(), h = 0 | vg(0 | (O = 0 | vg(0 | (G = 0 | vg(0 | (QA = 0 | vg(0 | (EA = 0 | vg(0 | eA, 0 | iA, 2097151 & EA | 0, 0)), 0 | o(), 0 | g, 0 | QA)), 0 | o(), 0 | K, 0 | G)), 0 | o(), 0 | p, 0 | O)), 0 | o(), 0 | S, 0 | h), S = 0 | o(), G = 0 | ig(0 | (O = 0 | vg(0 | x, 0 | q, 1048576, 0)), 0 | (p = 0 | o()), 21), K = 0 | o(), K = 0 | vg(0 | (IA = 0 | vg(0 | (F = 0 | vg(0 | (n = 0 | vg(0 | (R = 0 | vg(0 | (H = 0 | vg(0 | (gA = 0 | vg(0 | CA, 0 | BA, 2097151 & gA | 0, 0)), 0 | o(), 0 | I, 0 | H)), 0 | o(), 0 | P, 0 | R)), 0 | o(), 0 | m, 0 | n)), 0 | o(), 0 | r, 0 | F)), 0 | o(), 0 | k, 0 | IA)), 0 | o(), 0 | G, 0 | K), G = 0 | o(), F = 0 | ig(0 | (IA = 0 | vg(0 | i, 0 | v, 1048576, 0)), 0 | (k = 0 | o()), 21), r = 0 | o(), r = 0 | vg(0 | (z = 0 | vg(0 | (a = 0 | vg(0 | (b = 0 | vg(0 | (Y = 0 | vg(0 | f, 0 | w, 2097151 & Y | 0, 0)), 0 | o(), 0 | AA, 0 | b)), 0 | o(), 0 | M, 0 | a)), 0 | o(), 0 | W, 0 | z)), 0 | o(), 0 | F, 0 | r), F = 0 | o(), k = 0 | Ug(0 | i, 0 | v, -2097152 & IA | 0, 0 | k), IA = 0 | o(), z = 0 | vg(0 | U, 0 | E, 0 | (z = 0 | ig(0 | (v = 0 | vg(0 | D, 0 | X, 1048576, 0)), 0 | (i = 0 | o()), 21)), 0 | o()), E = 0 | o(), i = 0 | Ug(0 | D, 0 | X, -2097152 & v | 0, 0 | i), v = 0 | o(), L = 0 | vg(0 | (U = 0 | ig(0 | (X = 0 | vg(0 | e, 0 | c, 1048576, 0)), 0 | (D = 0 | o()), 21)), 0 | o(), 2097151 & L | 0, 0), U = 0 | o(), D = 0 | Ug(0 | e, 0 | c, -2097152 & X | 0, 0 | D), X = 0 | o(), W = 0 | yg(0 | (c = 0 | vg(0 | N, 0 | s, 1048576, 0)), 0 | (e = 0 | o()), 21), a = 0 | o(), e = 0 | Ug(0 | N, 0 | s, -2097152 & c | 0, 0 | e), c = 0 | o(), M = 0 | ig(0 | (s = 0 | vg(0 | h, 0 | S, 1048576, 0)), 0 | (N = 0 | o()), 21), b = 0 | o(), IA = 0 | vg(0 | (w = 0 | ig(0 | (AA = 0 | vg(0 | K, 0 | G, 1048576, 0)), 0 | (Y = 0 | o()), 21)), 0 | o(), 0 | k, 0 | IA), k = 0 | o(), Y = 0 | Ug(0 | K, 0 | G, -2097152 & AA | 0, 0 | Y), AA = 0 | o(), v = 0 | vg(0 | (w = 0 | ig(0 | (G = 0 | vg(0 | r, 0 | F, 1048576, 0)), 0 | (K = 0 | o()), 21)), 0 | o(), 0 | i, 0 | v), i = 0 | o(), K = 0 | Ug(0 | r, 0 | F, -2097152 & G | 0, 0 | K), G = 0 | o(), X = 0 | vg(0 | (w = 0 | ig(0 | (F = 0 | vg(0 | z, 0 | E, 1048576, 0)), 0 | (r = 0 | o()), 21)), 0 | o(), 0 | D, 0 | X), D = 0 | o(), r = 0 | Ug(0 | z, 0 | E, -2097152 & F | 0, 0 | r), F = 0 | o(), Z = 0 | vg(0 | (E = 0 | Qg(0 | L, 0 | U, 666643, 0)), 0 | o(), 2097151 & Z | 0, 0), E = 0 | o(), z = 0 | vg(0 | $, 0 | d, 0 | (z = 0 | Qg(0 | L, 0 | U, 470296, 0)), 0 | o()), d = 0 | o(), $ = 0 | vg(0 | e, 0 | c, 0 | ($ = 0 | Qg(0 | L, 0 | U, 654183, 0)), 0 | o()), c = 0 | o(), e = 0 | Qg(0 | L, 0 | U, -997805, -1), w = 0 | o(), f = 0 | Qg(0 | L, 0 | U, 136657, 0), n = 0 | o(), p = 0 | Ug(0 | (b = 0 | vg(0 | (q = 0 | vg(0 | (U = 0 | Qg(0 | L, 0 | U, -683901, -1)), 0 | o(), 0 | x, 0 | q)), 0 | o(), 0 | M, 0 | b)), 0 | o(), -2097152 & O | 0, 0 | p), O = 0 | o(), T = 0 | vg(0 | (b = 0 | Qg(0 | X, 0 | D, 666643, 0)), 0 | o(), 2097151 & T | 0, 0), b = 0 | o(), M = 0 | vg(0 | Z, 0 | E, 0 | (M = 0 | Qg(0 | X, 0 | D, 470296, 0)), 0 | o()), E = 0 | o(), Z = 0 | vg(0 | z, 0 | d, 0 | (Z = 0 | Qg(0 | X, 0 | D, 654183, 0)), 0 | o()), d = 0 | o(), z = 0 | vg(0 | $, 0 | c, 0 | (z = 0 | Qg(0 | X, 0 | D, -997805, -1)), 0 | o()), c = 0 | o(), $ = 0 | Qg(0 | X, 0 | D, 136657, 0), q = 0 | o(), D = 0 | Qg(0 | X, 0 | D, -683901, -1), X = 0 | o(), y = 0 | vg(0 | (x = 0 | Qg(0 | r, 0 | F, 666643, 0)), 0 | o(), 2097151 & y | 0, 0), x = 0 | o(), U = 0 | vg(0 | T, 0 | b, 0 | (U = 0 | Qg(0 | r, 0 | F, 470296, 0)), 0 | o()), b = 0 | o(), T = 0 | vg(0 | M, 0 | E, 0 | (T = 0 | Qg(0 | r, 0 | F, 654183, 0)), 0 | o()), E = 0 | o(), M = 0 | vg(0 | Z, 0 | d, 0 | (M = 0 | Qg(0 | r, 0 | F, -997805, -1)), 0 | o()), d = 0 | o(), Z = 0 | vg(0 | z, 0 | c, 0 | (Z = 0 | Qg(0 | r, 0 | F, 136657, 0)), 0 | o()), c = 0 | o(), F = 0 | Qg(0 | r, 0 | F, -683901, -1), r = 0 | o(), r = 0 | vg(0 | (q = 0 | vg(0 | (w = 0 | vg(0 | (l = 0 | Ug(0 | (t = 0 | vg(0 | W, 0 | a, 0 | _, 0 | t)), 0 | o(), -2097152 & u | 0, 0 | l)), 0 | o(), 0 | e, 0 | w)), 0 | o(), 0 | $, 0 | q)), 0 | o(), 0 | F, 0 | r), F = 0 | o(), J = 0 | vg(0 | (q = 0 | Qg(0 | v, 0 | i, 666643, 0)), 0 | o(), 2097151 & J | 0, 0), q = 0 | o(), $ = 0 | vg(0 | y, 0 | x, 0 | ($ = 0 | Qg(0 | v, 0 | i, 470296, 0)), 0 | o()), x = 0 | o(), y = 0 | vg(0 | U, 0 | b, 0 | (y = 0 | Qg(0 | v, 0 | i, 654183, 0)), 0 | o()), b = 0 | o(), U = 0 | vg(0 | T, 0 | E, 0 | (U = 0 | Qg(0 | v, 0 | i, -997805, -1)), 0 | o()), E = 0 | o(), T = 0 | vg(0 | M, 0 | d, 0 | (T = 0 | Qg(0 | v, 0 | i, 136657, 0)), 0 | o()), d = 0 | o(), i = 0 | vg(0 | Z, 0 | c, 0 | (i = 0 | Qg(0 | v, 0 | i, -683901, -1)), 0 | o()), c = 0 | o(), V = 0 | vg(0 | (Z = 0 | Qg(0 | K, 0 | G, 666643, 0)), 0 | o(), 2097151 & V | 0, 0), Z = 0 | o(), v = 0 | vg(0 | J, 0 | q, 0 | (v = 0 | Qg(0 | K, 0 | G, 470296, 0)), 0 | o()), q = 0 | o(), J = 0 | vg(0 | $, 0 | x, 0 | (J = 0 | Qg(0 | K, 0 | G, 654183, 0)), 0 | o()), x = 0 | o(), $ = 0 | vg(0 | y, 0 | b, 0 | ($ = 0 | Qg(0 | K, 0 | G, -997805, -1)), 0 | o()), b = 0 | o(), y = 0 | vg(0 | U, 0 | E, 0 | (y = 0 | Qg(0 | K, 0 | G, 136657, 0)), 0 | o()), E = 0 | o(), G = 0 | vg(0 | T, 0 | d, 0 | (G = 0 | Qg(0 | K, 0 | G, -683901, -1)), 0 | o()), d = 0 | o(), j = 0 | vg(0 | (T = 0 | Qg(0 | IA, 0 | k, 666643, 0)), 0 | o(), 2097151 & j | 0, 0), T = 0 | o(), K = 0 | vg(0 | V, 0 | Z, 0 | (K = 0 | Qg(0 | IA, 0 | k, 470296, 0)), 0 | o()), Z = 0 | o(), V = 0 | vg(0 | v, 0 | q, 0 | (V = 0 | Qg(0 | IA, 0 | k, 654183, 0)), 0 | o()), q = 0 | o(), v = 0 | vg(0 | J, 0 | x, 0 | (v = 0 | Qg(0 | IA, 0 | k, -997805, -1)), 0 | o()), x = 0 | o(), J = 0 | vg(0 | $, 0 | b, 0 | (J = 0 | Qg(0 | IA, 0 | k, 136657, 0)), 0 | o()), b = 0 | o(), k = 0 | vg(0 | y, 0 | E, 0 | (k = 0 | Qg(0 | IA, 0 | k, -683901, -1)), 0 | o()), E = 0 | o(), $ = 0 | vg(0 | K, 0 | Z, 0 | ($ = 0 | ig(0 | (y = 0 | vg(0 | j, 0 | T, 1048576, 0)), 0 | (IA = 0 | o()), 21)), 0 | o()), Z = 0 | o(), IA = 0 | Ug(0 | j, 0 | T, -2097152 & y | 0, 0 | IA), y = 0 | o(), K = 0 | vg(0 | v, 0 | x, 0 | (K = 0 | ig(0 | (T = 0 | vg(0 | V, 0 | q, 1048576, 0)), 0 | (j = 0 | o()), 21)), 0 | o()), x = 0 | o(), M = 0 | vg(0 | k, 0 | E, 0 | (M = 0 | ig(0 | (v = 0 | vg(0 | J, 0 | b, 1048576, 0)), 0 | (U = 0 | o()), 21)), 0 | o()), E = 0 | o(), e = 0 | vg(0 | i, 0 | c, 0 | (e = 0 | ig(0 | (k = 0 | vg(0 | G, 0 | d, 1048576, 0)), 0 | (w = 0 | o()), 21)), 0 | o()), c = 0 | o(), w = 0 | Ug(0 | G, 0 | d, -2097152 & k | 0, 0 | w), k = 0 | o(), i = 0 | ig(0 | (d = 0 | vg(0 | r, 0 | F, 1048576, 0)), 0 | (G = 0 | o()), 21), l = 0 | o(), l = 0 | vg(0 | (X = 0 | vg(0 | (N = 0 | Ug(0 | (S = 0 | vg(0 | f, 0 | n, 0 | h, 0 | S)), 0 | o(), -2097152 & s | 0, 0 | N)), 0 | o(), 0 | D, 0 | X)), 0 | o(), 0 | i, 0 | l), i = 0 | o(), G = 0 | Ug(0 | r, 0 | F, -2097152 & d | 0, 0 | G), d = 0 | o(), AA = 0 | vg(0 | (X = 0 | ig(0 | (F = 0 | vg(0 | p, 0 | O, 1048576, 0)), 0 | (r = 0 | o()), 21)), 0 | o(), 0 | Y, 0 | AA), Y = 0 | o(), r = 0 | Ug(0 | p, 0 | O, -2097152 & F | 0, 0 | r), F = 0 | o(), X = 0 | ig(0 | (O = 0 | vg(0 | $, 0 | Z, 1048576, 0)), 0 | (p = 0 | o()), 21), D = 0 | o(), S = 0 | ig(0 | (N = 0 | vg(0 | K, 0 | x, 1048576, 0)), 0 | (s = 0 | o()), 21), h = 0 | o(), u = 0 | vg(0 | w, 0 | k, 0 | (u = 0 | ig(0 | (n = 0 | vg(0 | M, 0 | E, 1048576, 0)), 0 | (f = 0 | o()), 21)), 0 | o()), k = 0 | o(), _ = 0 | vg(0 | G, 0 | d, 0 | (_ = 0 | ig(0 | (w = 0 | vg(0 | e, 0 | c, 1048576, 0)), 0 | (t = 0 | o()), 21)), 0 | o()), d = 0 | o(), t = 0 | Ug(0 | e, 0 | c, -2097152 & w | 0, 0 | t), w = 0 | o(), G = 0 | vg(0 | r, 0 | F, 0 | (G = 0 | ig(0 | (c = 0 | vg(0 | l, 0 | i, 1048576, 0)), 0 | (e = 0 | o()), 21)), 0 | o()), F = 0 | o(), e = 0 | Ug(0 | l, 0 | i, -2097152 & c | 0, 0 | e), c = 0 | o(), r = 0 | ig(0 | (i = 0 | vg(0 | AA, 0 | Y, 1048576, 0)), 0 | (l = 0 | o()), 21), a = 0 | o(), l = 0 | Ug(0 | AA, 0 | Y, -2097152 & i | 0, 0 | l), i = 0 | o(), Y = 0 | vg(0 | IA, 0 | y, 0 | (Y = 0 | Qg(0 | r, 0 | a, 666643, 0)), 0 | o()), y = 0 | o(), IA = 0 | Qg(0 | r, 0 | a, 470296, 0), AA = 0 | o(), W = 0 | Qg(0 | r, 0 | a, 654183, 0), z = 0 | o(), L = 0 | Qg(0 | r, 0 | a, -997805, -1), m = 0 | o(), R = 0 | Qg(0 | r, 0 | a, 136657, 0), P = 0 | o(), a = 0 | Qg(0 | r, 0 | a, -683901, -1), r = 0 | o(), y = 0 | ig(0 | Y, 0 | y, 21), H = 0 | o(), y = 0 | ig(0 | (H = 0 | vg(0 | (p = 0 | Ug(0 | (Z = 0 | vg(0 | IA, 0 | AA, 0 | $, 0 | Z)), 0 | o(), -2097152 & O | 0, 0 | p)), 0 | o(), 0 | y, 0 | H)), 0 | o(), 21), p = 0 | o(), y = 0 | ig(0 | (p = 0 | vg(0 | (D = 0 | vg(0 | (j = 0 | Ug(0 | (q = 0 | vg(0 | W, 0 | z, 0 | V, 0 | q)), 0 | o(), -2097152 & T | 0, 0 | j)), 0 | o(), 0 | X, 0 | D)), 0 | o(), 0 | y, 0 | p)), 0 | o(), 21), D = 0 | o(), y = 0 | ig(0 | (D = 0 | vg(0 | (s = 0 | Ug(0 | (m = 0 | vg(0 | K, 0 | x, 0 | L, 0 | m)), 0 | o(), -2097152 & N | 0, 0 | s)), 0 | o(), 0 | y, 0 | D)), 0 | o(), 21), s = 0 | o(), y = 0 | ig(0 | (s = 0 | vg(0 | (h = 0 | vg(0 | (U = 0 | Ug(0 | (b = 0 | vg(0 | R, 0 | P, 0 | J, 0 | b)), 0 | o(), -2097152 & v | 0, 0 | U)), 0 | o(), 0 | S, 0 | h)), 0 | o(), 0 | y, 0 | s)), 0 | o(), 21), h = 0 | o(), Y = 0 | vg(0 | (G = 0 | Qg(0 | (l = 0 | ig(0 | (i = 0 | vg(0 | (F = 0 | ig(0 | (e = 0 | vg(0 | G, 0 | F, 0 | (e = 0 | ig(0 | (c = 0 | vg(0 | (d = 0 | ig(0 | (t = 0 | vg(0 | _, 0 | d, 0 | (t = 0 | ig(0 | (w = 0 | vg(0 | (k = 0 | ig(0 | (y = 0 | vg(0 | u, 0 | k, 0 | (y = 0 | ig(0 | (h = 0 | vg(0 | (f = 0 | Ug(0 | (r = 0 | vg(0 | M, 0 | E, 0 | a, 0 | r)), 0 | o(), -2097152 & n | 0, 0 | f)), 0 | o(), 0 | y, 0 | h)), 0 | o(), 21)), 0 | o())), 0 | o(), 21)), 0 | o(), 0 | t, 0 | w)), 0 | o(), 21)), 0 | o())), 0 | o(), 21)), 0 | o(), 0 | e, 0 | c)), 0 | o(), 21)), 0 | o())), 0 | o(), 21)), 0 | o(), 0 | l, 0 | i)), 0 | o(), 21)), 0 | (F = 0 | o()), 666643, 0)), 0 | o(), 2097151 & Y | 0, 0), G = 0 | o(), H = 0 | vg(0 | (d = 0 | Qg(0 | l, 0 | F, 470296, 0)), 0 | o(), 2097151 & H | 0, 0), d = 0 | o(), p = 0 | vg(0 | (_ = 0 | Qg(0 | l, 0 | F, 654183, 0)), 0 | o(), 2097151 & p | 0, 0), _ = 0 | o(), D = 0 | vg(0 | (k = 0 | Qg(0 | l, 0 | F, -997805, -1)), 0 | o(), 2097151 & D | 0, 0), k = 0 | o(), s = 0 | vg(0 | (u = 0 | Qg(0 | l, 0 | F, 136657, 0)), 0 | o(), 2097151 & s | 0, 0), u = 0 | o(), i = 0 | vg(0 | (E = 0 | ig(0 | (e = 0 | vg(0 | (a = 0 | ig(0 | (c = 0 | vg(0 | (r = 0 | ig(0 | (t = 0 | vg(0 | (n = 0 | ig(0 | (w = 0 | vg(0 | (f = 0 | ig(0 | (y = 0 | vg(0 | (h = 0 | ig(0 | (s = 0 | vg(0 | (h = 0 | vg(0 | (F = 0 | Qg(0 | l, 0 | F, -683901, -1)), 0 | o(), 2097151 & h | 0, 0)), 0 | (F = 0 | o()), 0 | (s = 0 | ig(0 | (D = 0 | vg(0 | s, 0 | u, 0 | (D = 0 | ig(0 | (p = 0 | vg(0 | D, 0 | k, 0 | (p = 0 | ig(0 | (H = 0 | vg(0 | p, 0 | _, 0 | (H = 0 | ig(0 | (l = 0 | vg(0 | H, 0 | d, 0 | (l = 0 | ig(0 | Y, 0 | G, 21)), 0 | o())), 0 | (d = 0 | o()), 21)), 0 | o())), 0 | (_ = 0 | o()), 21)), 0 | o())), 0 | (k = 0 | o()), 21)), 0 | o())), 0 | (u = 0 | o()), 21)), 0 | o())), 0 | (F = 0 | o()), 21)), 0 | o(), 2097151 & y | 0, 0)), 0 | (h = 0 | o()), 21)), 0 | o(), 2097151 & w | 0, 0)), 0 | (f = 0 | o()), 21)), 0 | o(), 2097151 & t | 0, 0)), 0 | (n = 0 | o()), 21)), 0 | o(), 2097151 & c | 0, 0)), 0 | (r = 0 | o()), 21)), 0 | o(), 2097151 & e | 0, 0)), 0 | (a = 0 | o()), 21)), 0 | o(), 2097151 & i | 0, 0), E = 0 | o(), B[A >> 0] = Y, M = 0 | yg(0 | Y, 0 | G, 8), o(), B[A + 1 >> 0] = M, G = 0 | yg(0 | Y, 0 | G, 16), o(), Y = 0 | rg(2097151 & l | 0, 0, 5), o(), B[A + 2 >> 0] = Y | 31 & G, G = 0 | yg(0 | l, 0 | d, 3), o(), B[A + 3 >> 0] = G, d = 0 | yg(0 | l, 0 | d, 11), o(), B[A + 4 >> 0] = d, l = 0 | yg(2097151 & l | 0, 0, 19), d = 0 | o(), G = 0 | rg(2097151 & H | 0, 0, 2), o(), B[A + 5 >> 0] = G | l, _ = 0 | yg(0 | H, 0 | _, 6), o(), B[A + 6 >> 0] = _, H = 0 | yg(2097151 & H | 0, 0, 14), _ = 0 | o(), l = 0 | rg(2097151 & p | 0, 0, 7), o(), B[A + 7 >> 0] = l | H, H = 0 | yg(0 | p, 0 | k, 1), o(), B[A + 8 >> 0] = H, k = 0 | yg(0 | p, 0 | k, 9), o(), B[A + 9 >> 0] = k, p = 0 | yg(2097151 & p | 0, 0, 17), k = 0 | o(), H = 0 | rg(2097151 & D | 0, 0, 4), o(), B[A + 10 >> 0] = H | p, p = 0 | yg(0 | D, 0 | u, 4), o(), B[A + 11 >> 0] = p, u = 0 | yg(0 | D, 0 | u, 12), o(), B[A + 12 >> 0] = u, D = 0 | yg(2097151 & D | 0, 0, 20), u = 0 | o(), p = 0 | rg(2097151 & s | 0, 0, 1), o(), B[A + 13 >> 0] = p | D, F = 0 | yg(0 | s, 0 | F, 7), o(), B[A + 14 >> 0] = F, s = 0 | yg(2097151 & s | 0, 0, 15), F = 0 | o(), D = 0 | rg(2097151 & y | 0, 0, 6), o(), B[A + 15 >> 0] = D | s, s = 0 | yg(0 | y, 0 | h, 2), o(), B[A + 16 >> 0] = s, h = 0 | yg(0 | y, 0 | h, 10), o(), B[A + 17 >> 0] = h, y = 0 | yg(2097151 & y | 0, 0, 18), h = 0 | o(), s = 0 | rg(0 | w, 0 | f, 3), o(), B[A + 18 >> 0] = s | y, y = 0 | yg(0 | w, 0 | f, 5), o(), B[A + 19 >> 0] = y, f = 0 | yg(0 | w, 0 | f, 13), o(), B[A + 20 >> 0] = f, B[A + 21 >> 0] = t, f = 0 | yg(0 | t, 0 | n, 8), o(), B[A + 22 >> 0] = f, n = 0 | yg(0 | t, 0 | n, 16), o(), t = 0 | rg(2097151 & c | 0, 0, 5), o(), B[A + 23 >> 0] = t | 31 & n, n = 0 | yg(0 | c, 0 | r, 3), o(), B[A + 24 >> 0] = n, r = 0 | yg(0 | c, 0 | r, 11), o(), B[A + 25 >> 0] = r, c = 0 | yg(2097151 & c | 0, 0, 19), r = 0 | o(), n = 0 | rg(2097151 & e | 0, 0, 2), o(), B[A + 26 >> 0] = n | c, a = 0 | yg(0 | e, 0 | a, 6), o(), B[A + 27 >> 0] = a, e = 0 | yg(2097151 & e | 0, 0, 14), a = 0 | o(), c = 0 | rg(0 | i, 0 | E, 7), o(), B[A + 28 >> 0] = c | e, e = 0 | yg(0 | i, 0 | E, 1), o(), B[A + 29 >> 0] = e, e = 0 | yg(0 | i, 0 | E, 9), o(), B[A + 30 >> 0] = e, E = 0 | ig(0 | i, 0 | E, 17), o(), B[A + 31 >> 0] = E;
          }

          function u(A, I, g) {
            A |= 0, g |= 0;

            var B,
                Q,
                E,
                i,
                e,
                c,
                a,
                n,
                r,
                t,
                f,
                w,
                y,
                s,
                h,
                D,
                F,
                p,
                u,
                H,
                k,
                l,
                _,
                G,
                d,
                Y,
                M,
                S,
                U,
                v,
                b,
                J,
                P,
                R,
                N,
                m,
                L,
                x,
                K,
                X,
                j,
                T,
                q,
                V,
                z,
                W,
                O,
                Z,
                $,
                AA,
                IA,
                gA,
                BA,
                CA,
                QA,
                EA,
                iA,
                eA,
                oA,
                cA,
                aA,
                nA,
                rA,
                tA,
                fA,
                wA,
                yA,
                sA,
                hA,
                DA,
                FA,
                pA,
                uA,
                HA,
                kA,
                lA,
                _A,
                GA,
                dA,
                YA,
                MA,
                SA,
                UA,
                vA,
                bA,
                JA,
                PA,
                RA,
                NA,
                mA = 0,
                LA = 0,
                xA = 0,
                KA = 0,
                XA = 0,
                jA = 0,
                TA = 0,
                qA = 0,
                VA = 0,
                zA = 0,
                WA = 0,
                OA = 0,
                ZA = 0,
                $A = 0,
                AI = 0,
                II = 0,
                gI = 0,
                BI = 0,
                CI = 0,
                QI = 0,
                EI = 0,
                iI = 0,
                eI = 0,
                oI = 0,
                cI = 0,
                aI = 0,
                nI = 0,
                rI = 0,
                tI = 0,
                fI = 0,
                wI = 0,
                yI = 0,
                sI = 0,
                hI = 0,
                DI = 0,
                FI = 0,
                pI = 0,
                uI = 0,
                HI = 0,
                kI = 0,
                lI = 0,
                _I = 0,
                GI = 0,
                dI = 0,
                YI = 0,
                MI = 0,
                SI = 0,
                UI = 0,
                vI = 0,
                bI = 0,
                JI = 0,
                PI = 0,
                RI = 0,
                NI = 0,
                mI = 0,
                LI = 0,
                xI = 0,
                KI = 0,
                XI = 0,
                jI = 0,
                TI = 0,
                qI = 0,
                VI = 0,
                zI = 0,
                WI = 0,
                OI = 0,
                ZI = 0,
                $I = 0,
                Ag = 0,
                Ig = 0,
                gg = 0,
                Bg = 0,
                Cg = 0,
                Eg = 0,
                eg = 0,
                og = 0,
                cg = 0,
                ag = 0,
                ng = 0,
                rg = 0,
                tg = 0,
                fg = 0,
                wg = 0,
                sg = 0,
                hg = 0,
                Dg = 0,
                Fg = 0,
                pg = 0,
                ug = 0,
                Hg = 0,
                kg = 0,
                lg = 0,
                _g = 0,
                Gg = 0,
                dg = 0,
                Yg = 0,
                Mg = 0,
                Sg = 0,
                bg = 0,
                Jg = 0,
                Pg = 0,
                Rg = 0,
                Ng = 0,
                mg = 0,
                Lg = 0,
                xg = 0,
                Kg = 0,
                Xg = 0,
                jg = 0,
                Tg = 0;

            AI = 0 | C[(I |= 0) >> 2], qA = 0 | C[I + 4 >> 2], jA = 0 | C[I + 8 >> 2], ZA = 0 | C[I + 12 >> 2], SI = 0 | C[I + 16 >> 2], OA = 0 | C[I + 20 >> 2], eg = 0 | C[I + 24 >> 2], mA = 0 | C[I + 28 >> 2], pI = 0 | C[I + 32 >> 2], nI = 0 | C[I + 36 >> 2], oI = 0 | C[g >> 2], Tg = 0 | C[g + 4 >> 2], lg = 0 | C[g + 8 >> 2], Bg = 0 | C[g + 12 >> 2], RI = 0 | C[g + 16 >> 2], Yg = 0 | C[g + 20 >> 2], ag = 0 | C[g + 24 >> 2], KI = 0 | C[g + 28 >> 2], uI = 0 | C[g + 32 >> 2], NA = 0 | C[g + 36 >> 2], PA = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), jg = 0 | o(), dA = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), GA = 0 | o(), gA = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), Cg = 0 | o(), P = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), NI = 0 | o(), pA = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), Sg = 0 | o(), eA = 0 | Qg(0 | Yg, ((0 | Yg) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), rg = 0 | o(), K = 0 | Qg(0 | ag, ((0 | ag) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), jI = 0 | o(), H = 0 | Qg(0 | KI, ((0 | KI) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), kI = 0 | o(), t = 0 | Qg(0 | uI, ((0 | uI) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), rI = 0 | o(), AI = 0 | Qg(0 | NA, ((0 | NA) < 0) << 31 >> 31 | 0, 0 | AI, ((0 | AI) < 0) << 31 >> 31 | 0), $A = 0 | o(), _g = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | qA, ((0 | qA) < 0) << 31 >> 31 | 0), Gg = 0 | o(), QA = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, qA << 1 | 0, ((qA << 1 | 0) < 0) << 31 >> 31 | 0), CA = 0 | o(), R = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | qA, ((0 | qA) < 0) << 31 >> 31 | 0), mI = 0 | o(), uA = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, qA << 1 | 0, ((qA << 1 | 0) < 0) << 31 >> 31 | 0), bg = 0 | o(), oA = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | qA, ((0 | qA) < 0) << 31 >> 31 | 0), tg = 0 | o(), X = 0 | Qg(0 | Yg, ((0 | Yg) < 0) << 31 >> 31 | 0, qA << 1 | 0, ((qA << 1 | 0) < 0) << 31 >> 31 | 0), TI = 0 | o(), k = 0 | Qg(0 | ag, ((0 | ag) < 0) << 31 >> 31 | 0, 0 | qA, ((0 | qA) < 0) << 31 >> 31 | 0), lI = 0 | o(), f = 0 | Qg(0 | KI, ((0 | KI) < 0) << 31 >> 31 | 0, qA << 1 | 0, ((qA << 1 | 0) < 0) << 31 >> 31 | 0), tI = 0 | o(), B = 0 | Qg(0 | uI, ((0 | uI) < 0) << 31 >> 31 | 0, 0 | qA, ((0 | qA) < 0) << 31 >> 31 | 0), II = 0 | o(), qA = 0 | Qg(19 * NA | 0, 0 | (aI = ((19 * NA | 0) < 0) << 31 >> 31), qA << 1 | 0, ((qA << 1 | 0) < 0) << 31 >> 31 | 0), I = 0 | o(), BA = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), Eg = 0 | o(), L = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), m = 0 | o(), HA = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), Jg = 0 | o(), cA = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), fg = 0 | o(), j = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), qI = 0 | o(), l = 0 | Qg(0 | Yg, ((0 | Yg) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), _I = 0 | o(), w = 0 | Qg(0 | ag, ((0 | ag) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), fI = 0 | o(), Q = 0 | Qg(0 | KI, ((0 | KI) < 0) << 31 >> 31 | 0, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), gI = 0 | o(), YA = 0 | Qg(19 * uI | 0, 0 | (HI = ((19 * uI | 0) < 0) << 31 >> 31), 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), Rg = 0 | o(), jA = 0 | Qg(19 * NA | 0, 0 | aI, 0 | jA, ((0 | jA) < 0) << 31 >> 31 | 0), TA = 0 | o(), N = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | ZA, ((0 | ZA) < 0) << 31 >> 31 | 0), LI = 0 | o(), _A = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, ZA << 1 | 0, ((ZA << 1 | 0) < 0) << 31 >> 31 | 0), lA = 0 | o(), aA = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | ZA, ((0 | ZA) < 0) << 31 >> 31 | 0), wg = 0 | o(), T = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, ZA << 1 | 0, ((ZA << 1 | 0) < 0) << 31 >> 31 | 0), VI = 0 | o(), _ = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | ZA, ((0 | ZA) < 0) << 31 >> 31 | 0), GI = 0 | o(), y = 0 | Qg(0 | Yg, ((0 | Yg) < 0) << 31 >> 31 | 0, ZA << 1 | 0, ((ZA << 1 | 0) < 0) << 31 >> 31 | 0), wI = 0 | o(), E = 0 | Qg(0 | ag, ((0 | ag) < 0) << 31 >> 31 | 0, 0 | ZA, ((0 | ZA) < 0) << 31 >> 31 | 0), BI = 0 | o(), MA = 0 | Qg(19 * KI | 0, 0 | (XI = ((19 * KI | 0) < 0) << 31 >> 31), ZA << 1 | 0, ((ZA << 1 | 0) < 0) << 31 >> 31 | 0), Ng = 0 | o(), fA = 0 | Qg(19 * uI | 0, 0 | HI, 0 | ZA, ((0 | ZA) < 0) << 31 >> 31 | 0), hg = 0 | o(), ZA = 0 | Qg(19 * NA | 0, 0 | aI, ZA << 1 | 0, ((ZA << 1 | 0) < 0) << 31 >> 31 | 0), XA = 0 | o(), kA = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), Pg = 0 | o(), tA = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), rA = 0 | o(), q = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), zI = 0 | o(), G = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), dI = 0 | o(), s = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), yI = 0 | o(), i = 0 | Qg(0 | Yg, ((0 | Yg) < 0) << 31 >> 31 | 0, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), CI = 0 | o(), SA = 0 | Qg(19 * ag | 0, 0 | (ng = ((19 * ag | 0) < 0) << 31 >> 31), 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), mg = 0 | o(), wA = 0 | Qg(19 * KI | 0, 0 | XI, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), Dg = 0 | o(), O = 0 | Qg(19 * uI | 0, 0 | HI, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), OI = 0 | o(), SI = 0 | Qg(19 * NA | 0, 0 | aI, 0 | SI, ((0 | SI) < 0) << 31 >> 31 | 0), xA = 0 | o(), nA = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | OA, ((0 | OA) < 0) << 31 >> 31 | 0), sg = 0 | o(), W = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, OA << 1 | 0, ((OA << 1 | 0) < 0) << 31 >> 31 | 0), z = 0 | o(), d = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | OA, ((0 | OA) < 0) << 31 >> 31 | 0), YI = 0 | o(), h = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, OA << 1 | 0, ((OA << 1 | 0) < 0) << 31 >> 31 | 0), sI = 0 | o(), e = 0 | Qg(0 | RI, ((0 | RI) < 0) << 31 >> 31 | 0, 0 | OA, ((0 | OA) < 0) << 31 >> 31 | 0), QI = 0 | o(), UA = 0 | Qg(19 * Yg | 0, 0 | (Mg = ((19 * Yg | 0) < 0) << 31 >> 31), OA << 1 | 0, ((OA << 1 | 0) < 0) << 31 >> 31 | 0), Lg = 0 | o(), yA = 0 | Qg(19 * ag | 0, 0 | ng, 0 | OA, ((0 | OA) < 0) << 31 >> 31 | 0), Fg = 0 | o(), Z = 0 | Qg(19 * KI | 0, 0 | XI, OA << 1 | 0, ((OA << 1 | 0) < 0) << 31 >> 31 | 0), ZI = 0 | o(), U = 0 | Qg(19 * uI | 0, 0 | HI, 0 | OA, ((0 | OA) < 0) << 31 >> 31 | 0), UI = 0 | o(), OA = 0 | Qg(19 * NA | 0, 0 | aI, OA << 1 | 0, ((OA << 1 | 0) < 0) << 31 >> 31 | 0), LA = 0 | o(), V = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), WI = 0 | o(), S = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), M = 0 | o(), D = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), hI = 0 | o(), c = 0 | Qg(0 | Bg, ((0 | Bg) < 0) << 31 >> 31 | 0, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), EI = 0 | o(), vA = 0 | Qg(19 * RI | 0, ((19 * RI | 0) < 0) << 31 >> 31 | 0, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), xg = 0 | o(), sA = 0 | Qg(19 * Yg | 0, 0 | Mg, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), pg = 0 | o(), $ = 0 | Qg(19 * ag | 0, 0 | ng, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), $I = 0 | o(), v = 0 | Qg(19 * KI | 0, 0 | XI, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), vI = 0 | o(), VA = 0 | Qg(19 * uI | 0, 0 | HI, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), zA = 0 | o(), eg = 0 | Qg(19 * NA | 0, 0 | aI, 0 | eg, ((0 | eg) < 0) << 31 >> 31 | 0), KA = 0 | o(), Y = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | mA, ((0 | mA) < 0) << 31 >> 31 | 0), MI = 0 | o(), u = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, mA << 1 | 0, ((mA << 1 | 0) < 0) << 31 >> 31 | 0), p = 0 | o(), a = 0 | Qg(0 | lg, ((0 | lg) < 0) << 31 >> 31 | 0, 0 | mA, ((0 | mA) < 0) << 31 >> 31 | 0), iI = 0 | o(), bA = 0 | Qg(19 * Bg | 0, ((19 * Bg | 0) < 0) << 31 >> 31 | 0, mA << 1 | 0, ((mA << 1 | 0) < 0) << 31 >> 31 | 0), Kg = 0 | o(), hA = 0 | Qg(19 * RI | 0, ((19 * RI | 0) < 0) << 31 >> 31 | 0, 0 | mA, ((0 | mA) < 0) << 31 >> 31 | 0), ug = 0 | o(), AA = 0 | Qg(19 * Yg | 0, 0 | Mg, mA << 1 | 0, ((mA << 1 | 0) < 0) << 31 >> 31 | 0), Ag = 0 | o(), b = 0 | Qg(19 * ag | 0, 0 | ng, 0 | mA, ((0 | mA) < 0) << 31 >> 31 | 0), bI = 0 | o(), cI = 0 | Qg(19 * KI | 0, 0 | XI, mA << 1 | 0, ((mA << 1 | 0) < 0) << 31 >> 31 | 0), WA = 0 | o(), EA = 0 | Qg(19 * uI | 0, 0 | HI, 0 | mA, ((0 | mA) < 0) << 31 >> 31 | 0), og = 0 | o(), g = 0 | Qg(19 * NA | 0, 0 | aI, mA << 1 | 0, ((mA << 1 | 0) < 0) << 31 >> 31 | 0), mA = 0 | o(), F = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), DI = 0 | o(), r = 0 | Qg(0 | Tg, ((0 | Tg) < 0) << 31 >> 31 | 0, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), n = 0 | o(), JA = 0 | Qg(19 * lg | 0, ((19 * lg | 0) < 0) << 31 >> 31 | 0, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), Xg = 0 | o(), DA = 0 | Qg(19 * Bg | 0, ((19 * Bg | 0) < 0) << 31 >> 31 | 0, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), Hg = 0 | o(), IA = 0 | Qg(19 * RI | 0, ((19 * RI | 0) < 0) << 31 >> 31 | 0, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), Ig = 0 | o(), J = 0 | Qg(19 * Yg | 0, 0 | Mg, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), JI = 0 | o(), FA = 0 | Qg(19 * ag | 0, 0 | ng, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), dg = 0 | o(), iA = 0 | Qg(19 * KI | 0, 0 | XI, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), cg = 0 | o(), x = 0 | Qg(19 * uI | 0, 0 | HI, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), xI = 0 | o(), pI = 0 | Qg(19 * NA | 0, 0 | aI, 0 | pI, ((0 | pI) < 0) << 31 >> 31 | 0), FI = 0 | o(), oI = 0 | Qg(0 | oI, ((0 | oI) < 0) << 31 >> 31 | 0, 0 | nI, ((0 | nI) < 0) << 31 >> 31 | 0), eI = 0 | o(), Tg = 0 | Qg(19 * Tg | 0, ((19 * Tg | 0) < 0) << 31 >> 31 | 0, nI << 1 | 0, ((nI << 1 | 0) < 0) << 31 >> 31 | 0), RA = 0 | o(), lg = 0 | Qg(19 * lg | 0, ((19 * lg | 0) < 0) << 31 >> 31 | 0, 0 | nI, ((0 | nI) < 0) << 31 >> 31 | 0), kg = 0 | o(), Bg = 0 | Qg(19 * Bg | 0, ((19 * Bg | 0) < 0) << 31 >> 31 | 0, nI << 1 | 0, ((nI << 1 | 0) < 0) << 31 >> 31 | 0), gg = 0 | o(), RI = 0 | Qg(19 * RI | 0, ((19 * RI | 0) < 0) << 31 >> 31 | 0, 0 | nI, ((0 | nI) < 0) << 31 >> 31 | 0), PI = 0 | o(), Mg = 0 | Qg(19 * Yg | 0, 0 | Mg, nI << 1 | 0, ((nI << 1 | 0) < 0) << 31 >> 31 | 0), Yg = 0 | o(), ng = 0 | Qg(19 * ag | 0, 0 | ng, 0 | nI, ((0 | nI) < 0) << 31 >> 31 | 0), ag = 0 | o(), XI = 0 | Qg(19 * KI | 0, 0 | XI, nI << 1 | 0, ((nI << 1 | 0) < 0) << 31 >> 31 | 0), KI = 0 | o(), HI = 0 | Qg(19 * uI | 0, 0 | HI, 0 | nI, ((0 | nI) < 0) << 31 >> 31 | 0), uI = 0 | o(), nI = 0 | Qg(19 * NA | 0, 0 | aI, nI << 1 | 0, ((nI << 1 | 0) < 0) << 31 >> 31 | 0), aI = 0 | o(), I = 0 | vg(0 | (Rg = 0 | vg(0 | (Ng = 0 | vg(0 | (mg = 0 | vg(0 | (Lg = 0 | vg(0 | (xg = 0 | vg(0 | (Kg = 0 | vg(0 | (Xg = 0 | vg(0 | (jg = 0 | vg(0 | Tg, 0 | RA, 0 | PA, 0 | jg)), 0 | o(), 0 | JA, 0 | Xg)), 0 | o(), 0 | bA, 0 | Kg)), 0 | o(), 0 | vA, 0 | xg)), 0 | o(), 0 | UA, 0 | Lg)), 0 | o(), 0 | SA, 0 | mg)), 0 | o(), 0 | MA, 0 | Ng)), 0 | o(), 0 | YA, 0 | Rg)), 0 | o(), 0 | qA, 0 | I), qA = 0 | o(), Gg = 0 | vg(0 | dA, 0 | GA, 0 | _g, 0 | Gg), _g = 0 | o(), LA = 0 | vg(0 | (zA = 0 | vg(0 | (WA = 0 | vg(0 | (dg = 0 | vg(0 | (Yg = 0 | vg(0 | (Sg = 0 | vg(0 | (bg = 0 | vg(0 | (Jg = 0 | vg(0 | (Pg = 0 | vg(0 | _A, 0 | lA, 0 | kA, 0 | Pg)), 0 | o(), 0 | HA, 0 | Jg)), 0 | o(), 0 | uA, 0 | bg)), 0 | o(), 0 | pA, 0 | Sg)), 0 | o(), 0 | Mg, 0 | Yg)), 0 | o(), 0 | FA, 0 | dg)), 0 | o(), 0 | cI, 0 | WA)), 0 | o(), 0 | VA, 0 | zA)), 0 | o(), 0 | OA, 0 | LA), OA = 0 | o(), WA = 0 | ig(0 | (zA = 0 | vg(0 | I, 0 | qA, 33554432, 0)), 0 | (VA = 0 | o()), 26), cI = 0 | o(), cI = 0 | vg(0 | (TA = 0 | vg(0 | (hg = 0 | vg(0 | (Dg = 0 | vg(0 | (Fg = 0 | vg(0 | (pg = 0 | vg(0 | (ug = 0 | vg(0 | (Hg = 0 | vg(0 | (kg = 0 | vg(0 | Gg, 0 | _g, 0 | lg, 0 | kg)), 0 | o(), 0 | DA, 0 | Hg)), 0 | o(), 0 | hA, 0 | ug)), 0 | o(), 0 | sA, 0 | pg)), 0 | o(), 0 | yA, 0 | Fg)), 0 | o(), 0 | wA, 0 | Dg)), 0 | o(), 0 | fA, 0 | hg)), 0 | o(), 0 | jA, 0 | TA)), 0 | o(), 0 | WA, 0 | cI), WA = 0 | o(), VA = 0 | Ug(0 | I, 0 | qA, -67108864 & zA | 0, 0 | VA), zA = 0 | o(), TA = 0 | ig(0 | (qA = 0 | vg(0 | LA, 0 | OA, 33554432, 0)), 0 | (I = 0 | o()), 26), jA = 0 | o(), jA = 0 | vg(0 | (KA = 0 | vg(0 | (og = 0 | vg(0 | (cg = 0 | vg(0 | (ag = 0 | vg(0 | (rg = 0 | vg(0 | (tg = 0 | vg(0 | (fg = 0 | vg(0 | (wg = 0 | vg(0 | (sg = 0 | vg(0 | tA, 0 | rA, 0 | nA, 0 | sg)), 0 | o(), 0 | aA, 0 | wg)), 0 | o(), 0 | cA, 0 | fg)), 0 | o(), 0 | oA, 0 | tg)), 0 | o(), 0 | eA, 0 | rg)), 0 | o(), 0 | ng, 0 | ag)), 0 | o(), 0 | iA, 0 | cg)), 0 | o(), 0 | EA, 0 | og)), 0 | o(), 0 | eg, 0 | KA)), 0 | o(), 0 | TA, 0 | jA), TA = 0 | o(), I = 0 | Ug(0 | LA, 0 | OA, -67108864 & qA | 0, 0 | I), qA = 0 | o(), LA = 0 | ig(0 | (OA = 0 | vg(0 | cI, 0 | WA, 16777216, 0)), 0 | o(), 25), KA = 0 | o(), KA = 0 | vg(0 | (XA = 0 | vg(0 | (OI = 0 | vg(0 | (ZI = 0 | vg(0 | ($I = 0 | vg(0 | (Ag = 0 | vg(0 | (Ig = 0 | vg(0 | (gg = 0 | vg(0 | (Cg = 0 | vg(0 | (Eg = 0 | vg(0 | QA, 0 | CA, 0 | BA, 0 | Eg)), 0 | o(), 0 | gA, 0 | Cg)), 0 | o(), 0 | Bg, 0 | gg)), 0 | o(), 0 | IA, 0 | Ig)), 0 | o(), 0 | AA, 0 | Ag)), 0 | o(), 0 | $, 0 | $I)), 0 | o(), 0 | Z, 0 | ZI)), 0 | o(), 0 | O, 0 | OI)), 0 | o(), 0 | ZA, 0 | XA)), 0 | o(), 0 | LA, 0 | KA), LA = 0 | o(), OA = 0 | Ug(0 | cI, 0 | WA, -33554432 & OA | 0, 0), WA = 0 | o(), XA = 0 | ig(0 | (cI = 0 | vg(0 | jA, 0 | TA, 16777216, 0)), 0 | o(), 25), ZA = 0 | o(), ZA = 0 | vg(0 | (mA = 0 | vg(0 | (xI = 0 | vg(0 | (KI = 0 | vg(0 | (jI = 0 | vg(0 | (TI = 0 | vg(0 | (qI = 0 | vg(0 | (VI = 0 | vg(0 | (zI = 0 | vg(0 | (WI = 0 | vg(0 | W, 0 | z, 0 | V, 0 | WI)), 0 | o(), 0 | q, 0 | zI)), 0 | o(), 0 | T, 0 | VI)), 0 | o(), 0 | j, 0 | qI)), 0 | o(), 0 | X, 0 | TI)), 0 | o(), 0 | K, 0 | jI)), 0 | o(), 0 | XI, 0 | KI)), 0 | o(), 0 | x, 0 | xI)), 0 | o(), 0 | g, 0 | mA)), 0 | o(), 0 | XA, 0 | ZA), XA = 0 | o(), cI = 0 | Ug(0 | jA, 0 | TA, -33554432 & cI | 0, 0), TA = 0 | o(), mA = 0 | ig(0 | (jA = 0 | vg(0 | KA, 0 | LA, 33554432, 0)), 0 | o(), 26), g = 0 | o(), g = 0 | vg(0 | (xA = 0 | vg(0 | (UI = 0 | vg(0 | (vI = 0 | vg(0 | (bI = 0 | vg(0 | (JI = 0 | vg(0 | (PI = 0 | vg(0 | (NI = 0 | vg(0 | (mI = 0 | vg(0 | (LI = 0 | vg(0 | L, 0 | m, 0 | N, 0 | LI)), 0 | o(), 0 | R, 0 | mI)), 0 | o(), 0 | P, 0 | NI)), 0 | o(), 0 | RI, 0 | PI)), 0 | o(), 0 | J, 0 | JI)), 0 | o(), 0 | b, 0 | bI)), 0 | o(), 0 | v, 0 | vI)), 0 | o(), 0 | U, 0 | UI)), 0 | o(), 0 | SI, 0 | xA)), 0 | o(), 0 | mA, 0 | g), mA = 0 | o(), jA = 0 | Ug(0 | KA, 0 | LA, -67108864 & jA | 0, 0), o(), KA = 0 | ig(0 | (LA = 0 | vg(0 | ZA, 0 | XA, 33554432, 0)), 0 | o(), 26), xA = 0 | o(), xA = 0 | vg(0 | (FI = 0 | vg(0 | (uI = 0 | vg(0 | (kI = 0 | vg(0 | (lI = 0 | vg(0 | (_I = 0 | vg(0 | (GI = 0 | vg(0 | (dI = 0 | vg(0 | (YI = 0 | vg(0 | (MI = 0 | vg(0 | S, 0 | M, 0 | Y, 0 | MI)), 0 | o(), 0 | d, 0 | YI)), 0 | o(), 0 | G, 0 | dI)), 0 | o(), 0 | _, 0 | GI)), 0 | o(), 0 | l, 0 | _I)), 0 | o(), 0 | k, 0 | lI)), 0 | o(), 0 | H, 0 | kI)), 0 | o(), 0 | HI, 0 | uI)), 0 | o(), 0 | pI, 0 | FI)), 0 | o(), 0 | KA, 0 | xA), KA = 0 | o(), LA = 0 | Ug(0 | ZA, 0 | XA, -67108864 & LA | 0, 0), o(), qA = 0 | vg(0 | (ZA = 0 | ig(0 | (XA = 0 | vg(0 | g, 0 | mA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | I, 0 | qA), I = 0 | o(), XA = 0 | Ug(0 | g, 0 | mA, -33554432 & XA | 0, 0), o(), g = 0 | ig(0 | (mA = 0 | vg(0 | xA, 0 | KA, 16777216, 0)), 0 | o(), 25), ZA = 0 | o(), ZA = 0 | vg(0 | (aI = 0 | vg(0 | (rI = 0 | vg(0 | (tI = 0 | vg(0 | (fI = 0 | vg(0 | (wI = 0 | vg(0 | (yI = 0 | vg(0 | (sI = 0 | vg(0 | (hI = 0 | vg(0 | (DI = 0 | vg(0 | u, 0 | p, 0 | F, 0 | DI)), 0 | o(), 0 | D, 0 | hI)), 0 | o(), 0 | h, 0 | sI)), 0 | o(), 0 | s, 0 | yI)), 0 | o(), 0 | y, 0 | wI)), 0 | o(), 0 | w, 0 | fI)), 0 | o(), 0 | f, 0 | tI)), 0 | o(), 0 | t, 0 | rI)), 0 | o(), 0 | nI, 0 | aI)), 0 | o(), 0 | g, 0 | ZA), g = 0 | o(), mA = 0 | Ug(0 | xA, 0 | KA, -33554432 & mA | 0, 0), o(), xA = 0 | vg(0 | cI, 0 | TA, 0 | (xA = 0 | yg(0 | (KA = 0 | vg(0 | qA, 0 | I, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), KA = 0 | Ug(0 | qA, 0 | I, -67108864 & KA | 0, 0), o(), qA = 0 | ig(0 | (I = 0 | vg(0 | ZA, 0 | g, 33554432, 0)), 0 | o(), 26), TA = 0 | o(), TA = 0 | vg(0 | ($A = 0 | vg(0 | (II = 0 | vg(0 | (gI = 0 | vg(0 | (BI = 0 | vg(0 | (CI = 0 | vg(0 | (QI = 0 | vg(0 | (EI = 0 | vg(0 | (iI = 0 | vg(0 | (eI = 0 | vg(0 | r, 0 | n, 0 | oI, 0 | eI)), 0 | o(), 0 | a, 0 | iI)), 0 | o(), 0 | c, 0 | EI)), 0 | o(), 0 | e, 0 | QI)), 0 | o(), 0 | i, 0 | CI)), 0 | o(), 0 | E, 0 | BI)), 0 | o(), 0 | Q, 0 | gI)), 0 | o(), 0 | B, 0 | II)), 0 | o(), 0 | AI, 0 | $A)), 0 | o(), 0 | qA, 0 | TA), qA = 0 | o(), I = 0 | Ug(0 | ZA, 0 | g, -67108864 & I | 0, 0), o(), zA = 0 | vg(0 | (ZA = 0 | Qg(0 | (ZA = 0 | ig(0 | (g = 0 | vg(0 | TA, 0 | qA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 19, 0)), 0 | o(), 0 | VA, 0 | zA), VA = 0 | o(), g = 0 | Ug(0 | TA, 0 | qA, -33554432 & g | 0, 0), o(), TA = 0 | vg(0 | OA, 0 | WA, 0 | (TA = 0 | yg(0 | (qA = 0 | vg(0 | zA, 0 | VA, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), qA = 0 | Ug(0 | zA, 0 | VA, -67108864 & qA | 0, 0), o(), C[A >> 2] = qA, C[A + 4 >> 2] = TA, C[A + 8 >> 2] = jA, C[A + 12 >> 2] = XA, C[A + 16 >> 2] = KA, C[A + 20 >> 2] = xA, C[A + 24 >> 2] = LA, C[A + 28 >> 2] = mA, C[A + 32 >> 2] = I, C[A + 36 >> 2] = g;
          }

          function H(A, I, g) {
            A |= 0, g |= 0;
            var B,
                Q,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0;
            B = y, Q = y = y + 63 & -64, y = y + 2048 | 0, fB(Q + 1024 | 0, I |= 0), SI(Q + 1024 | 0, A), fB(Q, Q + 1024 | 0), SI(Q, g), A = 0;

            do {
              i = 0 | C[Q + 1024 + ((4 | (I = A << 4)) << 3) >> 2], e = 0 | C[Q + 1024 + ((4 | I) << 3) + 4 >> 2], b = 0 | uI(0 | C[Q + 1024 + (I << 3) >> 2], 0 | C[Q + 1024 + (I << 3) + 4 >> 2], i, e), N = 0 | o(), Y = 0 | ZI(C[Q + 1024 + ((12 | I) << 3) >> 2] ^ b, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] ^ N, 32), H = 0 | o(), H = 0 | ZI((N = 0 | uI(b, N, e = 0 | ZI((F = 0 | uI(0 | C[Q + 1024 + ((8 | I) << 3) >> 2], 0 | C[Q + 1024 + ((8 | I) << 3) + 4 >> 2], Y, H)) ^ i, (D = 0 | o()) ^ e, 24), i = 0 | o())) ^ Y, (b = 0 | o()) ^ H, 16), Y = 0 | o(), C[Q + 1024 + ((12 | I) << 3) >> 2] = H, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] = Y, D = 0 | uI(F, D, H, Y), F = 0 | o(), C[Q + 1024 + ((8 | I) << 3) >> 2] = D, C[Q + 1024 + ((8 | I) << 3) + 4 >> 2] = F, i = 0 | ZI(D ^ e, F ^ i, 63), e = 0 | o(), C[Q + 1024 + ((4 | I) << 3) >> 2] = i, C[Q + 1024 + ((4 | I) << 3) + 4 >> 2] = e, U = 0 | C[Q + 1024 + ((5 | I) << 3) >> 2], v = 0 | C[Q + 1024 + ((5 | I) << 3) + 4 >> 2], _ = 0 | uI(0 | C[Q + 1024 + ((1 | I) << 3) >> 2], 0 | C[Q + 1024 + ((1 | I) << 3) + 4 >> 2], U, v), M = 0 | o(), p = 0 | ZI(C[Q + 1024 + ((13 | I) << 3) >> 2] ^ _, C[Q + 1024 + ((13 | I) << 3) + 4 >> 2] ^ M, 32), f = 0 | o(), a = 0 | uI(n = 0 | uI(0 | C[Q + 1024 + ((9 | I) << 3) >> 2], 0 | C[Q + 1024 + ((9 | I) << 3) + 4 >> 2], p, f), a = 0 | o(), f = 0 | ZI((M = 0 | uI(_, M, v = 0 | ZI(n ^ U, a ^ v, 24), U = 0 | o())) ^ p, (_ = 0 | o()) ^ f, 16), p = 0 | o()), n = 0 | o(), C[Q + 1024 + ((9 | I) << 3) >> 2] = a, C[Q + 1024 + ((9 | I) << 3) + 4 >> 2] = n, U = 0 | ZI(a ^ v, n ^ U, 63), v = 0 | o(), k = 0 | C[Q + 1024 + ((6 | I) << 3) >> 2], l = 0 | C[Q + 1024 + ((6 | I) << 3) + 4 >> 2], h = 0 | uI(0 | C[Q + 1024 + ((2 | I) << 3) >> 2], 0 | C[Q + 1024 + ((2 | I) << 3) + 4 >> 2], k, l), u = 0 | o(), r = 0 | ZI(C[Q + 1024 + ((14 | I) << 3) >> 2] ^ h, C[Q + 1024 + ((14 | I) << 3) + 4 >> 2] ^ u, 32), E = 0 | o(), k = 0 | ZI((J = 0 | uI(P = 0 | uI(0 | C[Q + 1024 + ((10 | I) << 3) >> 2], 0 | C[Q + 1024 + ((10 | I) << 3) + 4 >> 2], r, E), J = 0 | o(), E = 0 | ZI((u = 0 | uI(h, u, l = 0 | ZI(P ^ k, J ^ l, 24), k = 0 | o())) ^ r, (h = 0 | o()) ^ E, 16), r = 0 | o())) ^ l, (P = 0 | o()) ^ k, 63), l = 0 | o(), w = 0 | C[Q + 1024 + ((7 | I) << 3) >> 2], s = 0 | C[Q + 1024 + ((7 | I) << 3) + 4 >> 2], c = 0 | uI(0 | C[Q + 1024 + ((3 | I) << 3) >> 2], 0 | C[Q + 1024 + ((3 | I) << 3) + 4 >> 2], w, s), t = 0 | o(), R = 0 | ZI(C[Q + 1024 + ((15 | I) << 3) >> 2] ^ c, C[Q + 1024 + ((15 | I) << 3) + 4 >> 2] ^ t, 32), S = 0 | o(), w = 0 | ZI((G = 0 | uI(d = 0 | uI(0 | C[Q + 1024 + ((11 | I) << 3) >> 2], 0 | C[Q + 1024 + ((11 | I) << 3) + 4 >> 2], R, S), G = 0 | o(), S = 0 | ZI((t = 0 | uI(c, t, s = 0 | ZI(d ^ w, G ^ s, 24), w = 0 | o())) ^ R, (c = 0 | o()) ^ S, 16), R = 0 | o())) ^ s, (d = 0 | o()) ^ w, 63), s = 0 | o(), N = 0 | uI(b = 0 | uI(N, b, U, v), N = 0 | o(), v = 0 | ZI((P = 0 | uI(J, P, R = 0 | ZI(b ^ S, N ^ R, 32), S = 0 | o())) ^ U, (J = 0 | o()) ^ v, 24), U = 0 | o()), b = 0 | o(), C[Q + 1024 + (I << 3) >> 2] = N, C[Q + 1024 + (I << 3) + 4 >> 2] = b, S = 0 | ZI(N ^ R, b ^ S, 16), b = 0 | o(), C[Q + 1024 + ((15 | I) << 3) >> 2] = S, C[Q + 1024 + ((15 | I) << 3) + 4 >> 2] = b, b = 0 | uI(P, J, S, b), S = 0 | o(), C[Q + 1024 + ((10 | I) << 3) >> 2] = b, C[Q + 1024 + ((10 | I) << 3) + 4 >> 2] = S, U = 0 | ZI(b ^ v, S ^ U, 63), S = 0 | o(), C[Q + 1024 + ((5 | I) << 3) >> 2] = U, C[Q + 1024 + ((5 | I) << 3) + 4 >> 2] = S, M = 0 | uI(_ = 0 | uI(M, _, k, l), M = 0 | o(), l = 0 | ZI((d = 0 | uI(G, d, Y = 0 | ZI(_ ^ H, M ^ Y, 32), H = 0 | o())) ^ k, (G = 0 | o()) ^ l, 24), k = 0 | o()), _ = 0 | o(), C[Q + 1024 + ((1 | I) << 3) >> 2] = M, C[Q + 1024 + ((1 | I) << 3) + 4 >> 2] = _, H = 0 | ZI(M ^ Y, _ ^ H, 16), _ = 0 | o(), C[Q + 1024 + ((12 | I) << 3) >> 2] = H, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] = _, _ = 0 | uI(d, G, H, _), H = 0 | o(), C[Q + 1024 + ((11 | I) << 3) >> 2] = _, C[Q + 1024 + ((11 | I) << 3) + 4 >> 2] = H, k = 0 | ZI(_ ^ l, H ^ k, 63), H = 0 | o(), C[Q + 1024 + ((6 | I) << 3) >> 2] = k, C[Q + 1024 + ((6 | I) << 3) + 4 >> 2] = H, u = 0 | uI(h = 0 | uI(u, h, w, s), u = 0 | o(), s = 0 | ZI((F = 0 | uI(D, F, p = 0 | ZI(h ^ f, u ^ p, 32), f = 0 | o())) ^ w, (D = 0 | o()) ^ s, 24), w = 0 | o()), h = 0 | o(), C[Q + 1024 + ((2 | I) << 3) >> 2] = u, C[Q + 1024 + ((2 | I) << 3) + 4 >> 2] = h, f = 0 | ZI(u ^ p, h ^ f, 16), h = 0 | o(), C[Q + 1024 + ((13 | I) << 3) >> 2] = f, C[Q + 1024 + ((13 | I) << 3) + 4 >> 2] = h, h = 0 | uI(F, D, f, h), f = 0 | o(), C[Q + 1024 + ((8 | I) << 3) >> 2] = h, C[Q + 1024 + ((8 | I) << 3) + 4 >> 2] = f, w = 0 | ZI(h ^ s, f ^ w, 63), f = 0 | o(), C[Q + 1024 + ((7 | I) << 3) >> 2] = w, C[Q + 1024 + ((7 | I) << 3) + 4 >> 2] = f, t = 0 | uI(c = 0 | uI(t, c, i, e), t = 0 | o(), e = 0 | ZI((n = 0 | uI(a, n, r = 0 | ZI(c ^ E, t ^ r, 32), E = 0 | o())) ^ i, (a = 0 | o()) ^ e, 24), i = 0 | o()), c = 0 | o(), C[Q + 1024 + ((3 | I) << 3) >> 2] = t, C[Q + 1024 + ((3 | I) << 3) + 4 >> 2] = c, E = 0 | ZI(t ^ r, c ^ E, 16), c = 0 | o(), C[Q + 1024 + ((14 | I) << 3) >> 2] = E, C[Q + 1024 + ((14 | I) << 3) + 4 >> 2] = c, c = 0 | uI(n, a, E, c), E = 0 | o(), C[Q + 1024 + ((9 | I) << 3) >> 2] = c, C[Q + 1024 + ((9 | I) << 3) + 4 >> 2] = E, i = 0 | ZI(c ^ e, E ^ i, 63), E = 0 | o(), C[Q + 1024 + ((4 | I) << 3) >> 2] = i, C[Q + 1024 + ((4 | I) << 3) + 4 >> 2] = E, A = A + 1 | 0;
            } while (8 != (0 | A));

            A = 0;

            do {
              P = 0 | C[(J = Q + 1024 + (32 + (N = A << 1) << 3) | 0) >> 2], J = 0 | C[J + 4 >> 2], c = 0 | uI(0 | C[Q + 1024 + (N << 3) >> 2], 0 | C[Q + 1024 + (N << 3) + 4 >> 2], P, J), I = 0 | o(), f = 0 | ZI(C[(f = Q + 1024 + (N + 96 << 3) | 0) >> 2] ^ c, C[f + 4 >> 2] ^ I, 32), F = 0 | o(), F = 0 | ZI((I = 0 | uI(c, I, J = 0 | ZI((k = 0 | uI(0 | C[(k = Q + 1024 + (N + 64 << 3) | 0) >> 2], 0 | C[k + 4 >> 2], f, F)) ^ P, (l = 0 | o()) ^ J, 24), P = 0 | o())) ^ f, (c = 0 | o()) ^ F, 16), f = 0 | o(), C[(r = Q + 1024 + (N + 96 << 3) | 0) >> 2] = F, C[r + 4 >> 2] = f, l = 0 | uI(k, l, F, f), k = 0 | o(), C[(r = Q + 1024 + (N + 64 << 3) | 0) >> 2] = l, C[r + 4 >> 2] = k, P = 0 | ZI(l ^ J, k ^ P, 63), J = 0 | o(), C[(r = Q + 1024 + (N + 32 << 3) | 0) >> 2] = P, C[r + 4 >> 2] = J, a = 0 | C[(r = Q + 1024 + (N + 33 << 3) | 0) >> 2], r = 0 | C[r + 4 >> 2], h = 0 | uI(0 | C[Q + 1024 + ((1 | N) << 3) >> 2], 0 | C[Q + 1024 + ((1 | N) << 3) + 4 >> 2], a, r), t = 0 | o(), H = 0 | ZI(C[(H = Q + 1024 + (N + 97 << 3) | 0) >> 2] ^ h, C[H + 4 >> 2] ^ t, 32), d = 0 | o(), v = 0 | uI(U = 0 | uI(0 | C[(U = Q + 1024 + (N + 65 << 3) | 0) >> 2], 0 | C[U + 4 >> 2], H, d), v = 0 | o(), d = 0 | ZI((t = 0 | uI(h, t, r = 0 | ZI(U ^ a, v ^ r, 24), a = 0 | o())) ^ H, (h = 0 | o()) ^ d, 16), H = 0 | o()), U = 0 | o(), C[(_ = Q + 1024 + (N + 65 << 3) | 0) >> 2] = v, C[_ + 4 >> 2] = U, a = 0 | ZI(v ^ r, U ^ a, 63), r = 0 | o(), _ = Q + 1024 + (N + 16 << 3) | 0, D = 0 | C[(p = Q + 1024 + (N + 48 << 3) | 0) >> 2], p = 0 | C[p + 4 >> 2], _ = 0 | uI(0 | C[_ >> 2], 0 | C[_ + 4 >> 2], D, p), u = 0 | o(), S = 0 | ZI(C[(S = Q + 1024 + (N + 112 << 3) | 0) >> 2] ^ _, C[S + 4 >> 2] ^ u, 32), R = 0 | o(), D = 0 | ZI((e = 0 | uI(i = 0 | uI(0 | C[(i = Q + 1024 + (N + 80 << 3) | 0) >> 2], 0 | C[i + 4 >> 2], S, R), e = 0 | o(), R = 0 | ZI((u = 0 | uI(_, u, p = 0 | ZI(i ^ D, e ^ p, 24), D = 0 | o())) ^ S, (_ = 0 | o()) ^ R, 16), S = 0 | o())) ^ p, (i = 0 | o()) ^ D, 63), p = 0 | o(), b = Q + 1024 + (N + 17 << 3) | 0, G = 0 | C[(Y = Q + 1024 + (N + 49 << 3) | 0) >> 2], Y = 0 | C[Y + 4 >> 2], b = 0 | uI(0 | C[b >> 2], 0 | C[b + 4 >> 2], G, Y), M = 0 | o(), E = 0 | ZI(C[(E = Q + 1024 + (N + 113 << 3) | 0) >> 2] ^ b, C[E + 4 >> 2] ^ M, 32), n = 0 | o(), G = 0 | ZI((s = 0 | uI(w = 0 | uI(0 | C[(w = Q + 1024 + (N + 81 << 3) | 0) >> 2], 0 | C[w + 4 >> 2], E, n), s = 0 | o(), n = 0 | ZI((M = 0 | uI(b, M, Y = 0 | ZI(w ^ G, s ^ Y, 24), G = 0 | o())) ^ E, (b = 0 | o()) ^ n, 16), E = 0 | o())) ^ Y, (w = 0 | o()) ^ G, 63), Y = 0 | o(), I = 0 | uI(c = 0 | uI(I, c, a, r), I = 0 | o(), r = 0 | ZI((i = 0 | uI(e, i, E = 0 | ZI(c ^ n, I ^ E, 32), n = 0 | o())) ^ a, (e = 0 | o()) ^ r, 24), a = 0 | o()), c = 0 | o(), C[Q + 1024 + (N << 3) >> 2] = I, C[Q + 1024 + (N << 3) + 4 >> 2] = c, n = 0 | ZI(I ^ E, c ^ n, 16), c = 0 | o(), C[(E = Q + 1024 + (N + 113 << 3) | 0) >> 2] = n, C[E + 4 >> 2] = c, c = 0 | uI(i, e, n, c), n = 0 | o(), C[(e = Q + 1024 + (N + 80 << 3) | 0) >> 2] = c, C[e + 4 >> 2] = n, a = 0 | ZI(c ^ r, n ^ a, 63), n = 0 | o(), C[(r = Q + 1024 + (N + 33 << 3) | 0) >> 2] = a, C[r + 4 >> 2] = n, t = 0 | uI(h = 0 | uI(t, h, D, p), t = 0 | o(), p = 0 | ZI((w = 0 | uI(s, w, f = 0 | ZI(h ^ F, t ^ f, 32), F = 0 | o())) ^ D, (s = 0 | o()) ^ p, 24), D = 0 | o()), h = 0 | o(), C[Q + 1024 + ((1 | N) << 3) >> 2] = t, C[Q + 1024 + ((1 | N) << 3) + 4 >> 2] = h, F = 0 | ZI(t ^ f, h ^ F, 16), h = 0 | o(), C[(f = Q + 1024 + (N + 96 << 3) | 0) >> 2] = F, C[f + 4 >> 2] = h, h = 0 | uI(w, s, F, h), F = 0 | o(), C[(s = Q + 1024 + (N + 81 << 3) | 0) >> 2] = h, C[s + 4 >> 2] = F, D = 0 | ZI(h ^ p, F ^ D, 63), F = 0 | o(), C[(p = Q + 1024 + (N + 48 << 3) | 0) >> 2] = D, C[p + 4 >> 2] = F, u = 0 | uI(_ = 0 | uI(u, _, G, Y), u = 0 | o(), Y = 0 | ZI((k = 0 | uI(l, k, H = 0 | ZI(_ ^ d, u ^ H, 32), d = 0 | o())) ^ G, (l = 0 | o()) ^ Y, 24), G = 0 | o()), _ = 0 | o(), C[(p = Q + 1024 + (N + 16 << 3) | 0) >> 2] = u, C[p + 4 >> 2] = _, d = 0 | ZI(u ^ H, _ ^ d, 16), _ = 0 | o(), C[(H = Q + 1024 + (N + 97 << 3) | 0) >> 2] = d, C[H + 4 >> 2] = _, _ = 0 | uI(k, l, d, _), d = 0 | o(), C[(l = Q + 1024 + (N + 64 << 3) | 0) >> 2] = _, C[l + 4 >> 2] = d, G = 0 | ZI(_ ^ Y, d ^ G, 63), d = 0 | o(), C[(Y = Q + 1024 + (N + 49 << 3) | 0) >> 2] = G, C[Y + 4 >> 2] = d, M = 0 | uI(b = 0 | uI(M, b, P, J), M = 0 | o(), J = 0 | ZI((U = 0 | uI(v, U, S = 0 | ZI(b ^ R, M ^ S, 32), R = 0 | o())) ^ P, (v = 0 | o()) ^ J, 24), P = 0 | o()), b = 0 | o(), C[(Y = Q + 1024 + (N + 17 << 3) | 0) >> 2] = M, C[Y + 4 >> 2] = b, R = 0 | ZI(M ^ S, b ^ R, 16), b = 0 | o(), C[(S = Q + 1024 + (N + 112 << 3) | 0) >> 2] = R, C[S + 4 >> 2] = b, b = 0 | uI(U, v, R, b), R = 0 | o(), C[(v = Q + 1024 + (N + 65 << 3) | 0) >> 2] = b, C[v + 4 >> 2] = R, P = 0 | ZI(b ^ J, R ^ P, 63), R = 0 | o(), C[(N = Q + 1024 + (N + 32 << 3) | 0) >> 2] = P, C[N + 4 >> 2] = R, A = A + 1 | 0;
            } while (8 != (0 | A));

            fB(g, Q), SI(g, Q + 1024 | 0), y = B;
          }

          function k(A, I, g) {
            A |= 0, g |= 0;
            var B,
                Q,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0;
            B = y, Q = y = y + 63 & -64, y = y + 2048 | 0, fB(Q + 1024 | 0, I |= 0), SI(Q + 1024 | 0, A), fB(Q, Q + 1024 | 0), A = 0;

            do {
              i = 0 | C[Q + 1024 + ((4 | (I = A << 4)) << 3) >> 2], e = 0 | C[Q + 1024 + ((4 | I) << 3) + 4 >> 2], b = 0 | uI(0 | C[Q + 1024 + (I << 3) >> 2], 0 | C[Q + 1024 + (I << 3) + 4 >> 2], i, e), N = 0 | o(), Y = 0 | ZI(C[Q + 1024 + ((12 | I) << 3) >> 2] ^ b, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] ^ N, 32), H = 0 | o(), H = 0 | ZI((N = 0 | uI(b, N, e = 0 | ZI((F = 0 | uI(0 | C[Q + 1024 + ((8 | I) << 3) >> 2], 0 | C[Q + 1024 + ((8 | I) << 3) + 4 >> 2], Y, H)) ^ i, (D = 0 | o()) ^ e, 24), i = 0 | o())) ^ Y, (b = 0 | o()) ^ H, 16), Y = 0 | o(), C[Q + 1024 + ((12 | I) << 3) >> 2] = H, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] = Y, D = 0 | uI(F, D, H, Y), F = 0 | o(), C[Q + 1024 + ((8 | I) << 3) >> 2] = D, C[Q + 1024 + ((8 | I) << 3) + 4 >> 2] = F, i = 0 | ZI(D ^ e, F ^ i, 63), e = 0 | o(), C[Q + 1024 + ((4 | I) << 3) >> 2] = i, C[Q + 1024 + ((4 | I) << 3) + 4 >> 2] = e, U = 0 | C[Q + 1024 + ((5 | I) << 3) >> 2], v = 0 | C[Q + 1024 + ((5 | I) << 3) + 4 >> 2], _ = 0 | uI(0 | C[Q + 1024 + ((1 | I) << 3) >> 2], 0 | C[Q + 1024 + ((1 | I) << 3) + 4 >> 2], U, v), M = 0 | o(), p = 0 | ZI(C[Q + 1024 + ((13 | I) << 3) >> 2] ^ _, C[Q + 1024 + ((13 | I) << 3) + 4 >> 2] ^ M, 32), f = 0 | o(), a = 0 | uI(n = 0 | uI(0 | C[Q + 1024 + ((9 | I) << 3) >> 2], 0 | C[Q + 1024 + ((9 | I) << 3) + 4 >> 2], p, f), a = 0 | o(), f = 0 | ZI((M = 0 | uI(_, M, v = 0 | ZI(n ^ U, a ^ v, 24), U = 0 | o())) ^ p, (_ = 0 | o()) ^ f, 16), p = 0 | o()), n = 0 | o(), C[Q + 1024 + ((9 | I) << 3) >> 2] = a, C[Q + 1024 + ((9 | I) << 3) + 4 >> 2] = n, U = 0 | ZI(a ^ v, n ^ U, 63), v = 0 | o(), k = 0 | C[Q + 1024 + ((6 | I) << 3) >> 2], l = 0 | C[Q + 1024 + ((6 | I) << 3) + 4 >> 2], h = 0 | uI(0 | C[Q + 1024 + ((2 | I) << 3) >> 2], 0 | C[Q + 1024 + ((2 | I) << 3) + 4 >> 2], k, l), u = 0 | o(), r = 0 | ZI(C[Q + 1024 + ((14 | I) << 3) >> 2] ^ h, C[Q + 1024 + ((14 | I) << 3) + 4 >> 2] ^ u, 32), E = 0 | o(), k = 0 | ZI((J = 0 | uI(P = 0 | uI(0 | C[Q + 1024 + ((10 | I) << 3) >> 2], 0 | C[Q + 1024 + ((10 | I) << 3) + 4 >> 2], r, E), J = 0 | o(), E = 0 | ZI((u = 0 | uI(h, u, l = 0 | ZI(P ^ k, J ^ l, 24), k = 0 | o())) ^ r, (h = 0 | o()) ^ E, 16), r = 0 | o())) ^ l, (P = 0 | o()) ^ k, 63), l = 0 | o(), w = 0 | C[Q + 1024 + ((7 | I) << 3) >> 2], s = 0 | C[Q + 1024 + ((7 | I) << 3) + 4 >> 2], c = 0 | uI(0 | C[Q + 1024 + ((3 | I) << 3) >> 2], 0 | C[Q + 1024 + ((3 | I) << 3) + 4 >> 2], w, s), t = 0 | o(), R = 0 | ZI(C[Q + 1024 + ((15 | I) << 3) >> 2] ^ c, C[Q + 1024 + ((15 | I) << 3) + 4 >> 2] ^ t, 32), S = 0 | o(), w = 0 | ZI((G = 0 | uI(d = 0 | uI(0 | C[Q + 1024 + ((11 | I) << 3) >> 2], 0 | C[Q + 1024 + ((11 | I) << 3) + 4 >> 2], R, S), G = 0 | o(), S = 0 | ZI((t = 0 | uI(c, t, s = 0 | ZI(d ^ w, G ^ s, 24), w = 0 | o())) ^ R, (c = 0 | o()) ^ S, 16), R = 0 | o())) ^ s, (d = 0 | o()) ^ w, 63), s = 0 | o(), N = 0 | uI(b = 0 | uI(N, b, U, v), N = 0 | o(), v = 0 | ZI((P = 0 | uI(J, P, R = 0 | ZI(b ^ S, N ^ R, 32), S = 0 | o())) ^ U, (J = 0 | o()) ^ v, 24), U = 0 | o()), b = 0 | o(), C[Q + 1024 + (I << 3) >> 2] = N, C[Q + 1024 + (I << 3) + 4 >> 2] = b, S = 0 | ZI(N ^ R, b ^ S, 16), b = 0 | o(), C[Q + 1024 + ((15 | I) << 3) >> 2] = S, C[Q + 1024 + ((15 | I) << 3) + 4 >> 2] = b, b = 0 | uI(P, J, S, b), S = 0 | o(), C[Q + 1024 + ((10 | I) << 3) >> 2] = b, C[Q + 1024 + ((10 | I) << 3) + 4 >> 2] = S, U = 0 | ZI(b ^ v, S ^ U, 63), S = 0 | o(), C[Q + 1024 + ((5 | I) << 3) >> 2] = U, C[Q + 1024 + ((5 | I) << 3) + 4 >> 2] = S, M = 0 | uI(_ = 0 | uI(M, _, k, l), M = 0 | o(), l = 0 | ZI((d = 0 | uI(G, d, Y = 0 | ZI(_ ^ H, M ^ Y, 32), H = 0 | o())) ^ k, (G = 0 | o()) ^ l, 24), k = 0 | o()), _ = 0 | o(), C[Q + 1024 + ((1 | I) << 3) >> 2] = M, C[Q + 1024 + ((1 | I) << 3) + 4 >> 2] = _, H = 0 | ZI(M ^ Y, _ ^ H, 16), _ = 0 | o(), C[Q + 1024 + ((12 | I) << 3) >> 2] = H, C[Q + 1024 + ((12 | I) << 3) + 4 >> 2] = _, _ = 0 | uI(d, G, H, _), H = 0 | o(), C[Q + 1024 + ((11 | I) << 3) >> 2] = _, C[Q + 1024 + ((11 | I) << 3) + 4 >> 2] = H, k = 0 | ZI(_ ^ l, H ^ k, 63), H = 0 | o(), C[Q + 1024 + ((6 | I) << 3) >> 2] = k, C[Q + 1024 + ((6 | I) << 3) + 4 >> 2] = H, u = 0 | uI(h = 0 | uI(u, h, w, s), u = 0 | o(), s = 0 | ZI((F = 0 | uI(D, F, p = 0 | ZI(h ^ f, u ^ p, 32), f = 0 | o())) ^ w, (D = 0 | o()) ^ s, 24), w = 0 | o()), h = 0 | o(), C[Q + 1024 + ((2 | I) << 3) >> 2] = u, C[Q + 1024 + ((2 | I) << 3) + 4 >> 2] = h, f = 0 | ZI(u ^ p, h ^ f, 16), h = 0 | o(), C[Q + 1024 + ((13 | I) << 3) >> 2] = f, C[Q + 1024 + ((13 | I) << 3) + 4 >> 2] = h, h = 0 | uI(F, D, f, h), f = 0 | o(), C[Q + 1024 + ((8 | I) << 3) >> 2] = h, C[Q + 1024 + ((8 | I) << 3) + 4 >> 2] = f, w = 0 | ZI(h ^ s, f ^ w, 63), f = 0 | o(), C[Q + 1024 + ((7 | I) << 3) >> 2] = w, C[Q + 1024 + ((7 | I) << 3) + 4 >> 2] = f, t = 0 | uI(c = 0 | uI(t, c, i, e), t = 0 | o(), e = 0 | ZI((n = 0 | uI(a, n, r = 0 | ZI(c ^ E, t ^ r, 32), E = 0 | o())) ^ i, (a = 0 | o()) ^ e, 24), i = 0 | o()), c = 0 | o(), C[Q + 1024 + ((3 | I) << 3) >> 2] = t, C[Q + 1024 + ((3 | I) << 3) + 4 >> 2] = c, E = 0 | ZI(t ^ r, c ^ E, 16), c = 0 | o(), C[Q + 1024 + ((14 | I) << 3) >> 2] = E, C[Q + 1024 + ((14 | I) << 3) + 4 >> 2] = c, c = 0 | uI(n, a, E, c), E = 0 | o(), C[Q + 1024 + ((9 | I) << 3) >> 2] = c, C[Q + 1024 + ((9 | I) << 3) + 4 >> 2] = E, i = 0 | ZI(c ^ e, E ^ i, 63), E = 0 | o(), C[Q + 1024 + ((4 | I) << 3) >> 2] = i, C[Q + 1024 + ((4 | I) << 3) + 4 >> 2] = E, A = A + 1 | 0;
            } while (8 != (0 | A));

            A = 0;

            do {
              P = 0 | C[(J = Q + 1024 + (32 + (N = A << 1) << 3) | 0) >> 2], J = 0 | C[J + 4 >> 2], c = 0 | uI(0 | C[Q + 1024 + (N << 3) >> 2], 0 | C[Q + 1024 + (N << 3) + 4 >> 2], P, J), I = 0 | o(), f = 0 | ZI(C[(f = Q + 1024 + (N + 96 << 3) | 0) >> 2] ^ c, C[f + 4 >> 2] ^ I, 32), F = 0 | o(), F = 0 | ZI((I = 0 | uI(c, I, J = 0 | ZI((k = 0 | uI(0 | C[(k = Q + 1024 + (N + 64 << 3) | 0) >> 2], 0 | C[k + 4 >> 2], f, F)) ^ P, (l = 0 | o()) ^ J, 24), P = 0 | o())) ^ f, (c = 0 | o()) ^ F, 16), f = 0 | o(), C[(r = Q + 1024 + (N + 96 << 3) | 0) >> 2] = F, C[r + 4 >> 2] = f, l = 0 | uI(k, l, F, f), k = 0 | o(), C[(r = Q + 1024 + (N + 64 << 3) | 0) >> 2] = l, C[r + 4 >> 2] = k, P = 0 | ZI(l ^ J, k ^ P, 63), J = 0 | o(), C[(r = Q + 1024 + (N + 32 << 3) | 0) >> 2] = P, C[r + 4 >> 2] = J, a = 0 | C[(r = Q + 1024 + (N + 33 << 3) | 0) >> 2], r = 0 | C[r + 4 >> 2], h = 0 | uI(0 | C[Q + 1024 + ((1 | N) << 3) >> 2], 0 | C[Q + 1024 + ((1 | N) << 3) + 4 >> 2], a, r), t = 0 | o(), H = 0 | ZI(C[(H = Q + 1024 + (N + 97 << 3) | 0) >> 2] ^ h, C[H + 4 >> 2] ^ t, 32), d = 0 | o(), v = 0 | uI(U = 0 | uI(0 | C[(U = Q + 1024 + (N + 65 << 3) | 0) >> 2], 0 | C[U + 4 >> 2], H, d), v = 0 | o(), d = 0 | ZI((t = 0 | uI(h, t, r = 0 | ZI(U ^ a, v ^ r, 24), a = 0 | o())) ^ H, (h = 0 | o()) ^ d, 16), H = 0 | o()), U = 0 | o(), C[(_ = Q + 1024 + (N + 65 << 3) | 0) >> 2] = v, C[_ + 4 >> 2] = U, a = 0 | ZI(v ^ r, U ^ a, 63), r = 0 | o(), _ = Q + 1024 + (N + 16 << 3) | 0, D = 0 | C[(p = Q + 1024 + (N + 48 << 3) | 0) >> 2], p = 0 | C[p + 4 >> 2], _ = 0 | uI(0 | C[_ >> 2], 0 | C[_ + 4 >> 2], D, p), u = 0 | o(), S = 0 | ZI(C[(S = Q + 1024 + (N + 112 << 3) | 0) >> 2] ^ _, C[S + 4 >> 2] ^ u, 32), R = 0 | o(), D = 0 | ZI((e = 0 | uI(i = 0 | uI(0 | C[(i = Q + 1024 + (N + 80 << 3) | 0) >> 2], 0 | C[i + 4 >> 2], S, R), e = 0 | o(), R = 0 | ZI((u = 0 | uI(_, u, p = 0 | ZI(i ^ D, e ^ p, 24), D = 0 | o())) ^ S, (_ = 0 | o()) ^ R, 16), S = 0 | o())) ^ p, (i = 0 | o()) ^ D, 63), p = 0 | o(), b = Q + 1024 + (N + 17 << 3) | 0, G = 0 | C[(Y = Q + 1024 + (N + 49 << 3) | 0) >> 2], Y = 0 | C[Y + 4 >> 2], b = 0 | uI(0 | C[b >> 2], 0 | C[b + 4 >> 2], G, Y), M = 0 | o(), E = 0 | ZI(C[(E = Q + 1024 + (N + 113 << 3) | 0) >> 2] ^ b, C[E + 4 >> 2] ^ M, 32), n = 0 | o(), G = 0 | ZI((s = 0 | uI(w = 0 | uI(0 | C[(w = Q + 1024 + (N + 81 << 3) | 0) >> 2], 0 | C[w + 4 >> 2], E, n), s = 0 | o(), n = 0 | ZI((M = 0 | uI(b, M, Y = 0 | ZI(w ^ G, s ^ Y, 24), G = 0 | o())) ^ E, (b = 0 | o()) ^ n, 16), E = 0 | o())) ^ Y, (w = 0 | o()) ^ G, 63), Y = 0 | o(), I = 0 | uI(c = 0 | uI(I, c, a, r), I = 0 | o(), r = 0 | ZI((i = 0 | uI(e, i, E = 0 | ZI(c ^ n, I ^ E, 32), n = 0 | o())) ^ a, (e = 0 | o()) ^ r, 24), a = 0 | o()), c = 0 | o(), C[Q + 1024 + (N << 3) >> 2] = I, C[Q + 1024 + (N << 3) + 4 >> 2] = c, n = 0 | ZI(I ^ E, c ^ n, 16), c = 0 | o(), C[(E = Q + 1024 + (N + 113 << 3) | 0) >> 2] = n, C[E + 4 >> 2] = c, c = 0 | uI(i, e, n, c), n = 0 | o(), C[(e = Q + 1024 + (N + 80 << 3) | 0) >> 2] = c, C[e + 4 >> 2] = n, a = 0 | ZI(c ^ r, n ^ a, 63), n = 0 | o(), C[(r = Q + 1024 + (N + 33 << 3) | 0) >> 2] = a, C[r + 4 >> 2] = n, t = 0 | uI(h = 0 | uI(t, h, D, p), t = 0 | o(), p = 0 | ZI((w = 0 | uI(s, w, f = 0 | ZI(h ^ F, t ^ f, 32), F = 0 | o())) ^ D, (s = 0 | o()) ^ p, 24), D = 0 | o()), h = 0 | o(), C[Q + 1024 + ((1 | N) << 3) >> 2] = t, C[Q + 1024 + ((1 | N) << 3) + 4 >> 2] = h, F = 0 | ZI(t ^ f, h ^ F, 16), h = 0 | o(), C[(f = Q + 1024 + (N + 96 << 3) | 0) >> 2] = F, C[f + 4 >> 2] = h, h = 0 | uI(w, s, F, h), F = 0 | o(), C[(s = Q + 1024 + (N + 81 << 3) | 0) >> 2] = h, C[s + 4 >> 2] = F, D = 0 | ZI(h ^ p, F ^ D, 63), F = 0 | o(), C[(p = Q + 1024 + (N + 48 << 3) | 0) >> 2] = D, C[p + 4 >> 2] = F, u = 0 | uI(_ = 0 | uI(u, _, G, Y), u = 0 | o(), Y = 0 | ZI((k = 0 | uI(l, k, H = 0 | ZI(_ ^ d, u ^ H, 32), d = 0 | o())) ^ G, (l = 0 | o()) ^ Y, 24), G = 0 | o()), _ = 0 | o(), C[(p = Q + 1024 + (N + 16 << 3) | 0) >> 2] = u, C[p + 4 >> 2] = _, d = 0 | ZI(u ^ H, _ ^ d, 16), _ = 0 | o(), C[(H = Q + 1024 + (N + 97 << 3) | 0) >> 2] = d, C[H + 4 >> 2] = _, _ = 0 | uI(k, l, d, _), d = 0 | o(), C[(l = Q + 1024 + (N + 64 << 3) | 0) >> 2] = _, C[l + 4 >> 2] = d, G = 0 | ZI(_ ^ Y, d ^ G, 63), d = 0 | o(), C[(Y = Q + 1024 + (N + 49 << 3) | 0) >> 2] = G, C[Y + 4 >> 2] = d, M = 0 | uI(b = 0 | uI(M, b, P, J), M = 0 | o(), J = 0 | ZI((U = 0 | uI(v, U, S = 0 | ZI(b ^ R, M ^ S, 32), R = 0 | o())) ^ P, (v = 0 | o()) ^ J, 24), P = 0 | o()), b = 0 | o(), C[(Y = Q + 1024 + (N + 17 << 3) | 0) >> 2] = M, C[Y + 4 >> 2] = b, R = 0 | ZI(M ^ S, b ^ R, 16), b = 0 | o(), C[(S = Q + 1024 + (N + 112 << 3) | 0) >> 2] = R, C[S + 4 >> 2] = b, b = 0 | uI(U, v, R, b), R = 0 | o(), C[(v = Q + 1024 + (N + 65 << 3) | 0) >> 2] = b, C[v + 4 >> 2] = R, P = 0 | ZI(b ^ J, R ^ P, 63), R = 0 | o(), C[(N = Q + 1024 + (N + 32 << 3) | 0) >> 2] = P, C[N + 4 >> 2] = R, A = A + 1 | 0;
            } while (8 != (0 | A));

            fB(g, Q), SI(g, Q + 1024 | 0), y = B;
          }

          function l(A, I) {
            A |= 0;

            var g,
                B,
                Q,
                E,
                i,
                e,
                c,
                a,
                n,
                r,
                t,
                f,
                w,
                y,
                s,
                h,
                D,
                F,
                p,
                u,
                H,
                k,
                l,
                _,
                G,
                d,
                Y,
                M,
                S,
                U,
                v,
                b,
                J,
                P,
                R,
                N,
                m,
                L,
                x,
                K,
                X,
                j,
                T,
                q,
                V,
                z,
                W,
                O,
                Z,
                $,
                AA,
                IA,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0,
                tA = 0,
                fA = 0,
                wA = 0,
                yA = 0,
                sA = 0,
                hA = 0,
                DA = 0,
                FA = 0,
                pA = 0,
                uA = 0,
                HA = 0,
                kA = 0,
                lA = 0,
                _A = 0,
                GA = 0,
                dA = 0,
                YA = 0,
                MA = 0,
                SA = 0,
                UA = 0,
                vA = 0,
                bA = 0,
                JA = 0,
                PA = 0,
                RA = 0,
                NA = 0,
                mA = 0,
                LA = 0,
                xA = 0,
                KA = 0,
                XA = 0,
                jA = 0,
                TA = 0,
                qA = 0,
                VA = 0,
                zA = 0,
                WA = 0,
                OA = 0,
                ZA = 0,
                $A = 0,
                AI = 0,
                II = 0,
                gI = 0,
                BI = 0,
                CI = 0;

            oA = 0 | C[(I |= 0) >> 2], wA = 0 | C[I + 4 >> 2], rA = 0 | C[I + 8 >> 2], FA = 0 | C[I + 12 >> 2], BA = 0 | C[I + 16 >> 2], pA = 0 | C[I + 20 >> 2], yA = 0 | C[I + 24 >> 2], iA = 0 | C[I + 28 >> 2], EA = 0 | C[I + 32 >> 2], I = 0 | C[I + 36 >> 2], $ = 0 | Qg(0 | oA, ((0 | oA) < 0) << 31 >> 31 | 0, 0 | oA, ((0 | oA) < 0) << 31 >> 31 | 0), CI = 0 | o(), q = 0 | Qg(oA << 1 | 0, 0 | (cA = ((oA << 1 | 0) < 0) << 31 >> 31), 0 | wA, ((0 | wA) < 0) << 31 >> 31 | 0), AI = 0 | o(), X = 0 | Qg(0 | rA, ((0 | rA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), K = 0 | o(), R = 0 | Qg(0 | FA, ((0 | FA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), P = 0 | o(), Y = 0 | Qg(0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), KA = 0 | o(), k = 0 | Qg(0 | pA, ((0 | pA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), RA = 0 | o(), h = 0 | Qg(0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), vA = 0 | o(), t = 0 | Qg(0 | iA, ((0 | iA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), dA = 0 | o(), i = 0 | Qg(0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), kA = 0 | o(), cA = 0 | Qg(0 | I, ((0 | I) < 0) << 31 >> 31 | 0, oA << 1 | 0, 0 | cA), oA = 0 | o(), x = 0 | Qg(wA << 1 | 0, 0 | (gA = ((wA << 1 | 0) < 0) << 31 >> 31), 0 | wA, ((0 | wA) < 0) << 31 >> 31 | 0), OA = 0 | o(), J = 0 | Qg(wA << 1 | 0, 0 | gA, 0 | rA, ((0 | rA) < 0) << 31 >> 31 | 0), qA = 0 | o(), U = 0 | Qg(FA << 1 | 0, 0 | (CA = ((FA << 1 | 0) < 0) << 31 >> 31), wA << 1 | 0, 0 | gA), S = 0 | o(), G = 0 | Qg(0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0, wA << 1 | 0, 0 | gA), _ = 0 | o(), D = 0 | Qg(pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0, wA << 1 | 0, 0 | gA), bA = 0 | o(), f = 0 | Qg(0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0, wA << 1 | 0, 0 | gA), YA = 0 | o(), e = 0 | Qg(iA << 1 | 0, ((iA << 1 | 0) < 0) << 31 >> 31 | 0, wA << 1 | 0, 0 | gA), lA = 0 | o(), aA = 0 | Qg(0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0, wA << 1 | 0, 0 | gA), nA = 0 | o(), gA = 0 | Qg(38 * I | 0, 0 | (fA = ((38 * I | 0) < 0) << 31 >> 31), wA << 1 | 0, 0 | gA), wA = 0 | o(), M = 0 | Qg(0 | rA, ((0 | rA) < 0) << 31 >> 31 | 0, 0 | rA, ((0 | rA) < 0) << 31 >> 31 | 0), XA = 0 | o(), l = 0 | Qg(rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0, 0 | FA, ((0 | FA) < 0) << 31 >> 31 | 0), NA = 0 | o(), F = 0 | Qg(0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0, rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0), JA = 0 | o(), s = 0 | Qg(0 | pA, ((0 | pA) < 0) << 31 >> 31 | 0, rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0), y = 0 | o(), r = 0 | Qg(0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0, rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0), n = 0 | o(), g = 0 | Qg(0 | iA, ((0 | iA) < 0) << 31 >> 31 | 0, rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0), uA = 0 | o(), W = 0 | Qg(19 * EA | 0, 0 | (UA = ((19 * EA | 0) < 0) << 31 >> 31), rA << 1 | 0, ((rA << 1 | 0) < 0) << 31 >> 31 | 0), II = 0 | o(), rA = 0 | Qg(38 * I | 0, 0 | fA, 0 | rA, ((0 | rA) < 0) << 31 >> 31 | 0), sA = 0 | o(), u = 0 | Qg(FA << 1 | 0, 0 | CA, 0 | FA, ((0 | FA) < 0) << 31 >> 31 | 0), p = 0 | o(), w = 0 | Qg(FA << 1 | 0, 0 | CA, 0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0), MA = 0 | o(), c = 0 | Qg(pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0, FA << 1 | 0, 0 | CA), _A = 0 | o(), E = 0 | Qg(0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0, FA << 1 | 0, 0 | CA), Q = 0 | o(), O = 0 | Qg(38 * iA | 0, 0 | (xA = ((38 * iA | 0) < 0) << 31 >> 31), FA << 1 | 0, 0 | CA), gI = 0 | o(), j = 0 | Qg(19 * EA | 0, 0 | UA, FA << 1 | 0, 0 | CA), ZA = 0 | o(), CA = 0 | Qg(38 * I | 0, 0 | fA, FA << 1 | 0, 0 | CA), FA = 0 | o(), a = 0 | Qg(0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0, 0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0), GA = 0 | o(), B = 0 | Qg(BA << 1 | 0, ((BA << 1 | 0) < 0) << 31 >> 31 | 0, 0 | pA, ((0 | pA) < 0) << 31 >> 31 | 0), HA = 0 | o(), Z = 0 | Qg(19 * yA | 0, ((19 * yA | 0) < 0) << 31 >> 31 | 0, BA << 1 | 0, ((BA << 1 | 0) < 0) << 31 >> 31 | 0), BI = 0 | o(), T = 0 | Qg(38 * iA | 0, 0 | xA, 0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0), $A = 0 | o(), N = 0 | Qg(19 * EA | 0, 0 | UA, BA << 1 | 0, ((BA << 1 | 0) < 0) << 31 >> 31 | 0), VA = 0 | o(), BA = 0 | Qg(38 * I | 0, 0 | fA, 0 | BA, ((0 | BA) < 0) << 31 >> 31 | 0), hA = 0 | o(), IA = 0 | Qg(38 * pA | 0, ((38 * pA | 0) < 0) << 31 >> 31 | 0, 0 | pA, ((0 | pA) < 0) << 31 >> 31 | 0), AA = 0 | o(), z = 0 | Qg(19 * yA | 0, ((19 * yA | 0) < 0) << 31 >> 31 | 0, pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0), V = 0 | o(), m = 0 | Qg(38 * iA | 0, 0 | xA, pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0), zA = 0 | o(), v = 0 | Qg(19 * EA | 0, 0 | UA, pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0), jA = 0 | o(), pA = 0 | Qg(38 * I | 0, 0 | fA, pA << 1 | 0, ((pA << 1 | 0) < 0) << 31 >> 31 | 0), tA = 0 | o(), L = 0 | Qg(19 * yA | 0, ((19 * yA | 0) < 0) << 31 >> 31 | 0, 0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0), WA = 0 | o(), b = 0 | Qg(38 * iA | 0, 0 | xA, 0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0), TA = 0 | o(), d = 0 | Qg(19 * EA | 0, 0 | UA, yA << 1 | 0, ((yA << 1 | 0) < 0) << 31 >> 31 | 0), mA = 0 | o(), yA = 0 | Qg(38 * I | 0, 0 | fA, 0 | yA, ((0 | yA) < 0) << 31 >> 31 | 0), eA = 0 | o(), xA = 0 | Qg(38 * iA | 0, 0 | xA, 0 | iA, ((0 | iA) < 0) << 31 >> 31 | 0), LA = 0 | o(), H = 0 | Qg(19 * EA | 0, 0 | UA, iA << 1 | 0, ((iA << 1 | 0) < 0) << 31 >> 31 | 0), PA = 0 | o(), iA = 0 | Qg(38 * I | 0, 0 | fA, iA << 1 | 0, ((iA << 1 | 0) < 0) << 31 >> 31 | 0), DA = 0 | o(), UA = 0 | Qg(19 * EA | 0, 0 | UA, 0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0), SA = 0 | o(), EA = 0 | Qg(38 * I | 0, 0 | fA, 0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0), QA = 0 | o(), I = 0 | Qg(38 * I | 0, 0 | fA, 0 | I, ((0 | I) < 0) << 31 >> 31 | 0), fA = 0 | o(), wA = 0 | vg(0 | (II = 0 | vg(0 | (gI = 0 | vg(0 | (BI = 0 | vg(0 | (CI = 0 | vg(0 | IA, 0 | AA, 0 | $, 0 | CI)), 0 | o(), 0 | Z, 0 | BI)), 0 | o(), 0 | O, 0 | gI)), 0 | o(), 0 | W, 0 | II)), 0 | o(), 0 | gA, 0 | wA), gA = 0 | o(), sA = 0 | vg(0 | (ZA = 0 | vg(0 | ($A = 0 | vg(0 | (AI = 0 | vg(0 | z, 0 | V, 0 | q, 0 | AI)), 0 | o(), 0 | T, 0 | $A)), 0 | o(), 0 | j, 0 | ZA)), 0 | o(), 0 | rA, 0 | sA), rA = 0 | o(), FA = 0 | vg(0 | (VA = 0 | vg(0 | (zA = 0 | vg(0 | (WA = 0 | vg(0 | (OA = 0 | vg(0 | X, 0 | K, 0 | x, 0 | OA)), 0 | o(), 0 | L, 0 | WA)), 0 | o(), 0 | m, 0 | zA)), 0 | o(), 0 | N, 0 | VA)), 0 | o(), 0 | CA, 0 | FA), CA = 0 | o(), hA = 0 | vg(0 | (jA = 0 | vg(0 | (TA = 0 | vg(0 | (qA = 0 | vg(0 | R, 0 | P, 0 | J, 0 | qA)), 0 | o(), 0 | b, 0 | TA)), 0 | o(), 0 | v, 0 | jA)), 0 | o(), 0 | BA, 0 | hA), BA = 0 | o(), tA = 0 | vg(0 | (mA = 0 | vg(0 | (LA = 0 | vg(0 | (KA = 0 | vg(0 | (XA = 0 | vg(0 | U, 0 | S, 0 | M, 0 | XA)), 0 | o(), 0 | Y, 0 | KA)), 0 | o(), 0 | xA, 0 | LA)), 0 | o(), 0 | d, 0 | mA)), 0 | o(), 0 | pA, 0 | tA), pA = 0 | o(), eA = 0 | vg(0 | (PA = 0 | vg(0 | (RA = 0 | vg(0 | (NA = 0 | vg(0 | G, 0 | _, 0 | l, 0 | NA)), 0 | o(), 0 | k, 0 | RA)), 0 | o(), 0 | H, 0 | PA)), 0 | o(), 0 | yA, 0 | eA), yA = 0 | o(), DA = 0 | vg(0 | (SA = 0 | vg(0 | (vA = 0 | vg(0 | (bA = 0 | vg(0 | (JA = 0 | vg(0 | u, 0 | p, 0 | F, 0 | JA)), 0 | o(), 0 | D, 0 | bA)), 0 | o(), 0 | h, 0 | vA)), 0 | o(), 0 | UA, 0 | SA)), 0 | o(), 0 | iA, 0 | DA), iA = 0 | o(), QA = 0 | vg(0 | (dA = 0 | vg(0 | (YA = 0 | vg(0 | (MA = 0 | vg(0 | s, 0 | y, 0 | w, 0 | MA)), 0 | o(), 0 | f, 0 | YA)), 0 | o(), 0 | t, 0 | dA)), 0 | o(), 0 | EA, 0 | QA), EA = 0 | o(), fA = 0 | vg(0 | (kA = 0 | vg(0 | (lA = 0 | vg(0 | (_A = 0 | vg(0 | (GA = 0 | vg(0 | r, 0 | n, 0 | a, 0 | GA)), 0 | o(), 0 | c, 0 | _A)), 0 | o(), 0 | e, 0 | lA)), 0 | o(), 0 | i, 0 | kA)), 0 | o(), 0 | I, 0 | fA), I = 0 | o(), oA = 0 | vg(0 | (nA = 0 | vg(0 | (uA = 0 | vg(0 | (HA = 0 | vg(0 | E, 0 | Q, 0 | B, 0 | HA)), 0 | o(), 0 | g, 0 | uA)), 0 | o(), 0 | aA, 0 | nA)), 0 | o(), 0 | cA, 0 | oA), cA = 0 | o(), gA = 0 | rg(0 | wA, 0 | gA, 1), wA = 0 | o(), rA = 0 | rg(0 | sA, 0 | rA, 1), sA = 0 | o(), CA = 0 | rg(0 | FA, 0 | CA, 1), FA = 0 | o(), BA = 0 | rg(0 | hA, 0 | BA, 1), hA = 0 | o(), pA = 0 | rg(0 | tA, 0 | pA, 1), tA = 0 | o(), yA = 0 | rg(0 | eA, 0 | yA, 1), eA = 0 | o(), iA = 0 | rg(0 | DA, 0 | iA, 1), DA = 0 | o(), EA = 0 | rg(0 | QA, 0 | EA, 1), QA = 0 | o(), I = 0 | rg(0 | fA, 0 | I, 1), fA = 0 | o(), cA = 0 | rg(0 | oA, 0 | cA, 1), oA = 0 | o(), sA = 0 | vg(0 | (uA = 0 | ig(0 | (nA = 0 | vg(0 | gA, 0 | wA, 33554432, 0)), 0 | (aA = 0 | o()), 26)), 0 | o(), 0 | rA, 0 | sA), rA = 0 | o(), aA = 0 | Ug(0 | gA, 0 | wA, -67108864 & nA | 0, 0 | aA), nA = 0 | o(), eA = 0 | vg(0 | (uA = 0 | ig(0 | (wA = 0 | vg(0 | pA, 0 | tA, 33554432, 0)), 0 | (gA = 0 | o()), 26)), 0 | o(), 0 | yA, 0 | eA), yA = 0 | o(), gA = 0 | Ug(0 | pA, 0 | tA, -67108864 & wA | 0, 0 | gA), wA = 0 | o(), FA = 0 | vg(0 | (pA = 0 | ig(0 | (tA = 0 | vg(0 | sA, 0 | rA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | CA, 0 | FA), CA = 0 | o(), tA = 0 | Ug(0 | sA, 0 | rA, -33554432 & tA | 0, 0), rA = 0 | o(), DA = 0 | vg(0 | (pA = 0 | ig(0 | (sA = 0 | vg(0 | eA, 0 | yA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | iA, 0 | DA), iA = 0 | o(), sA = 0 | Ug(0 | eA, 0 | yA, -33554432 & sA | 0, 0), yA = 0 | o(), hA = 0 | vg(0 | (pA = 0 | ig(0 | (eA = 0 | vg(0 | FA, 0 | CA, 33554432, 0)), 0 | o(), 26)), 0 | o(), 0 | BA, 0 | hA), BA = 0 | o(), eA = 0 | Ug(0 | FA, 0 | CA, -67108864 & eA | 0, 0), o(), QA = 0 | vg(0 | (FA = 0 | ig(0 | (CA = 0 | vg(0 | DA, 0 | iA, 33554432, 0)), 0 | o(), 26)), 0 | o(), 0 | EA, 0 | QA), EA = 0 | o(), CA = 0 | Ug(0 | DA, 0 | iA, -67108864 & CA | 0, 0), o(), wA = 0 | vg(0 | (DA = 0 | ig(0 | (iA = 0 | vg(0 | hA, 0 | BA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | gA, 0 | wA), gA = 0 | o(), iA = 0 | Ug(0 | hA, 0 | BA, -33554432 & iA | 0, 0), o(), fA = 0 | vg(0 | (hA = 0 | ig(0 | (BA = 0 | vg(0 | QA, 0 | EA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | I, 0 | fA), I = 0 | o(), BA = 0 | Ug(0 | QA, 0 | EA, -33554432 & BA | 0, 0), o(), QA = 0 | vg(0 | sA, 0 | yA, 0 | (QA = 0 | yg(0 | (EA = 0 | vg(0 | wA, 0 | gA, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), EA = 0 | Ug(0 | wA, 0 | gA, -67108864 & EA | 0, 0), o(), oA = 0 | vg(0 | (wA = 0 | ig(0 | (gA = 0 | vg(0 | fA, 0 | I, 33554432, 0)), 0 | o(), 26)), 0 | o(), 0 | cA, 0 | oA), cA = 0 | o(), gA = 0 | Ug(0 | fA, 0 | I, -67108864 & gA | 0, 0), o(), nA = 0 | vg(0 | (fA = 0 | Qg(0 | (fA = 0 | ig(0 | (I = 0 | vg(0 | oA, 0 | cA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 19, 0)), 0 | o(), 0 | aA, 0 | nA), aA = 0 | o(), I = 0 | Ug(0 | oA, 0 | cA, -33554432 & I | 0, 0), o(), oA = 0 | vg(0 | tA, 0 | rA, 0 | (oA = 0 | yg(0 | (cA = 0 | vg(0 | nA, 0 | aA, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), cA = 0 | Ug(0 | nA, 0 | aA, -67108864 & cA | 0, 0), o(), C[A >> 2] = cA, C[A + 4 >> 2] = oA, C[A + 8 >> 2] = eA, C[A + 12 >> 2] = iA, C[A + 16 >> 2] = EA, C[A + 20 >> 2] = QA, C[A + 24 >> 2] = CA, C[A + 28 >> 2] = BA, C[A + 32 >> 2] = gA, C[A + 36 >> 2] = I;
          }

          function _(A, I) {
            A |= 0;

            var g,
                B,
                Q,
                E,
                i,
                e,
                c,
                a,
                n,
                r,
                t,
                f,
                w,
                y,
                s,
                h,
                D,
                F,
                p,
                u,
                H,
                k,
                l,
                _,
                G,
                d,
                Y,
                M,
                S,
                U,
                v,
                b,
                J,
                P,
                R,
                N,
                m,
                L,
                x,
                K,
                X,
                j,
                T,
                q,
                V,
                z,
                W,
                O,
                Z,
                $,
                AA = 0,
                IA = 0,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0,
                tA = 0,
                fA = 0,
                wA = 0,
                yA = 0,
                sA = 0,
                hA = 0,
                DA = 0,
                FA = 0,
                pA = 0,
                uA = 0,
                HA = 0,
                kA = 0,
                lA = 0,
                _A = 0,
                GA = 0,
                dA = 0,
                YA = 0,
                MA = 0,
                SA = 0,
                UA = 0,
                vA = 0,
                bA = 0,
                JA = 0,
                PA = 0,
                RA = 0,
                NA = 0,
                mA = 0,
                LA = 0,
                xA = 0,
                KA = 0,
                XA = 0,
                jA = 0,
                TA = 0,
                qA = 0,
                VA = 0,
                zA = 0,
                WA = 0,
                OA = 0,
                ZA = 0,
                $A = 0,
                AI = 0,
                II = 0,
                gI = 0,
                BI = 0,
                CI = 0;

            tA = 0 | C[(I |= 0) >> 2], AA = 0 | C[I + 4 >> 2], EA = 0 | C[I + 8 >> 2], QA = 0 | C[I + 12 >> 2], MA = 0 | C[I + 16 >> 2], nA = 0 | C[I + 20 >> 2], TA = 0 | C[I + 24 >> 2], IA = 0 | C[I + 28 >> 2], _A = 0 | C[I + 32 >> 2], FA = 0 | C[I + 36 >> 2], O = 0 | Qg(0 | tA, ((0 | tA) < 0) << 31 >> 31 | 0, 0 | tA, ((0 | tA) < 0) << 31 >> 31 | 0), CI = 0 | o(), P = 0 | Qg(tA << 1 | 0, 0 | (fA = ((tA << 1 | 0) < 0) << 31 >> 31), 0 | AA, ((0 | AA) < 0) << 31 >> 31 | 0), ZA = 0 | o(), q = 0 | Qg(0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), T = 0 | o(), j = 0 | Qg(0 | QA, ((0 | QA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), X = 0 | o(), m = 0 | Qg(0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), $A = 0 | o(), M = 0 | Qg(0 | nA, ((0 | nA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), VA = 0 | o(), p = 0 | Qg(0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), RA = 0 | o(), f = 0 | Qg(0 | IA, ((0 | IA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), GA = 0 | o(), e = 0 | Qg(0 | _A, ((0 | _A) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), pA = 0 | o(), fA = 0 | Qg(0 | FA, ((0 | FA) < 0) << 31 >> 31 | 0, tA << 1 | 0, 0 | fA), tA = 0 | o(), XA = 0 | Qg(AA << 1 | 0, 0 | (eA = ((AA << 1 | 0) < 0) << 31 >> 31), 0 | AA, ((0 | AA) < 0) << 31 >> 31 | 0), jA = 0 | o(), vA = 0 | Qg(AA << 1 | 0, 0 | eA, 0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0), bA = 0 | o(), K = 0 | Qg(QA << 1 | 0, 0 | (rA = ((QA << 1 | 0) < 0) << 31 >> 31), AA << 1 | 0, 0 | eA), x = 0 | o(), v = 0 | Qg(0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0, AA << 1 | 0, 0 | eA), U = 0 | o(), u = 0 | Qg(nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0, AA << 1 | 0, 0 | eA), NA = 0 | o(), w = 0 | Qg(0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0, AA << 1 | 0, 0 | eA), dA = 0 | o(), c = 0 | Qg(IA << 1 | 0, ((IA << 1 | 0) < 0) << 31 >> 31 | 0, AA << 1 | 0, 0 | eA), uA = 0 | o(), g = 0 | Qg(0 | _A, ((0 | _A) < 0) << 31 >> 31 | 0, AA << 1 | 0, 0 | eA), wA = 0 | o(), eA = 0 | Qg(38 * FA | 0, 0 | (DA = ((38 * FA | 0) < 0) << 31 >> 31), AA << 1 | 0, 0 | eA), AA = 0 | o(), L = 0 | Qg(0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0, 0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0), AI = 0 | o(), S = 0 | Qg(EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0, 0 | QA, ((0 | QA) < 0) << 31 >> 31 | 0), zA = 0 | o(), H = 0 | Qg(0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0, EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0), mA = 0 | o(), h = 0 | Qg(0 | nA, ((0 | nA) < 0) << 31 >> 31 | 0, EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0), s = 0 | o(), t = 0 | Qg(0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0, EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0), r = 0 | o(), B = 0 | Qg(0 | IA, ((0 | IA) < 0) << 31 >> 31 | 0, EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0), yA = 0 | o(), V = 0 | Qg(19 * _A | 0, 0 | (PA = ((19 * _A | 0) < 0) << 31 >> 31), EA << 1 | 0, ((EA << 1 | 0) < 0) << 31 >> 31 | 0), II = 0 | o(), EA = 0 | Qg(38 * FA | 0, 0 | DA, 0 | EA, ((0 | EA) < 0) << 31 >> 31 | 0), iA = 0 | o(), l = 0 | Qg(QA << 1 | 0, 0 | rA, 0 | QA, ((0 | QA) < 0) << 31 >> 31 | 0), k = 0 | o(), y = 0 | Qg(QA << 1 | 0, 0 | rA, 0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0), YA = 0 | o(), a = 0 | Qg(nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0, QA << 1 | 0, 0 | rA), HA = 0 | o(), i = 0 | Qg(0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0, QA << 1 | 0, 0 | rA), E = 0 | o(), z = 0 | Qg(38 * IA | 0, 0 | (hA = ((38 * IA | 0) < 0) << 31 >> 31), QA << 1 | 0, 0 | rA), gI = 0 | o(), b = 0 | Qg(19 * _A | 0, 0 | PA, QA << 1 | 0, 0 | rA), WA = 0 | o(), rA = 0 | Qg(38 * FA | 0, 0 | DA, QA << 1 | 0, 0 | rA), QA = 0 | o(), n = 0 | Qg(0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0, 0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0), kA = 0 | o(), Q = 0 | Qg(MA << 1 | 0, ((MA << 1 | 0) < 0) << 31 >> 31 | 0, 0 | nA, ((0 | nA) < 0) << 31 >> 31 | 0), sA = 0 | o(), W = 0 | Qg(19 * TA | 0, ((19 * TA | 0) < 0) << 31 >> 31 | 0, MA << 1 | 0, ((MA << 1 | 0) < 0) << 31 >> 31 | 0), BI = 0 | o(), J = 0 | Qg(38 * IA | 0, 0 | hA, 0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0), OA = 0 | o(), _ = 0 | Qg(19 * _A | 0, 0 | PA, MA << 1 | 0, ((MA << 1 | 0) < 0) << 31 >> 31 | 0), LA = 0 | o(), MA = 0 | Qg(38 * FA | 0, 0 | DA, 0 | MA, ((0 | MA) < 0) << 31 >> 31 | 0), BA = 0 | o(), $ = 0 | Qg(38 * nA | 0, ((38 * nA | 0) < 0) << 31 >> 31 | 0, 0 | nA, ((0 | nA) < 0) << 31 >> 31 | 0), Z = 0 | o(), N = 0 | Qg(19 * TA | 0, ((19 * TA | 0) < 0) << 31 >> 31 | 0, nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0), R = 0 | o(), G = 0 | Qg(38 * IA | 0, 0 | hA, nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0), xA = 0 | o(), D = 0 | Qg(19 * _A | 0, 0 | PA, nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0), SA = 0 | o(), nA = 0 | Qg(38 * FA | 0, 0 | DA, nA << 1 | 0, ((nA << 1 | 0) < 0) << 31 >> 31 | 0), gA = 0 | o(), d = 0 | Qg(19 * TA | 0, ((19 * TA | 0) < 0) << 31 >> 31 | 0, 0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0), KA = 0 | o(), F = 0 | Qg(38 * IA | 0, 0 | hA, 0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0), UA = 0 | o(), oA = 0 | Qg(19 * _A | 0, 0 | PA, TA << 1 | 0, ((TA << 1 | 0) < 0) << 31 >> 31 | 0), cA = 0 | o(), TA = 0 | Qg(38 * FA | 0, 0 | DA, 0 | TA, ((0 | TA) < 0) << 31 >> 31 | 0), CA = 0 | o(), hA = 0 | Qg(38 * IA | 0, 0 | hA, 0 | IA, ((0 | IA) < 0) << 31 >> 31 | 0), aA = 0 | o(), Y = 0 | Qg(19 * _A | 0, 0 | PA, IA << 1 | 0, ((IA << 1 | 0) < 0) << 31 >> 31 | 0), qA = 0 | o(), I = 0 | Qg(38 * FA | 0, 0 | DA, IA << 1 | 0, ((IA << 1 | 0) < 0) << 31 >> 31 | 0), IA = 0 | o(), PA = 0 | Qg(19 * _A | 0, 0 | PA, 0 | _A, ((0 | _A) < 0) << 31 >> 31 | 0), JA = 0 | o(), _A = 0 | Qg(38 * FA | 0, 0 | DA, 0 | _A, ((0 | _A) < 0) << 31 >> 31 | 0), lA = 0 | o(), FA = 0 | Qg(38 * FA | 0, 0 | DA, 0 | FA, ((0 | FA) < 0) << 31 >> 31 | 0), DA = 0 | o(), AA = 0 | vg(0 | (II = 0 | vg(0 | (gI = 0 | vg(0 | (BI = 0 | vg(0 | (CI = 0 | vg(0 | $, 0 | Z, 0 | O, 0 | CI)), 0 | o(), 0 | W, 0 | BI)), 0 | o(), 0 | z, 0 | gI)), 0 | o(), 0 | V, 0 | II)), 0 | o(), 0 | eA, 0 | AA), eA = 0 | o(), jA = 0 | vg(0 | q, 0 | T, 0 | XA, 0 | jA), XA = 0 | o(), bA = 0 | vg(0 | j, 0 | X, 0 | vA, 0 | bA), vA = 0 | o(), gA = 0 | vg(0 | (cA = 0 | vg(0 | (aA = 0 | vg(0 | ($A = 0 | vg(0 | (AI = 0 | vg(0 | K, 0 | x, 0 | L, 0 | AI)), 0 | o(), 0 | m, 0 | $A)), 0 | o(), 0 | hA, 0 | aA)), 0 | o(), 0 | oA, 0 | cA)), 0 | o(), 0 | nA, 0 | gA), nA = 0 | o(), aA = 0 | ig(0 | (cA = 0 | vg(0 | AA, 0 | eA, 33554432, 0)), 0 | (oA = 0 | o()), 26), hA = 0 | o(), hA = 0 | vg(0 | (iA = 0 | vg(0 | (WA = 0 | vg(0 | (OA = 0 | vg(0 | (ZA = 0 | vg(0 | N, 0 | R, 0 | P, 0 | ZA)), 0 | o(), 0 | J, 0 | OA)), 0 | o(), 0 | b, 0 | WA)), 0 | o(), 0 | EA, 0 | iA)), 0 | o(), 0 | aA, 0 | hA), aA = 0 | o(), oA = 0 | Ug(0 | AA, 0 | eA, -67108864 & cA | 0, 0 | oA), cA = 0 | o(), iA = 0 | ig(0 | (eA = 0 | vg(0 | gA, 0 | nA, 33554432, 0)), 0 | (AA = 0 | o()), 26), EA = 0 | o(), EA = 0 | vg(0 | (CA = 0 | vg(0 | (qA = 0 | vg(0 | (VA = 0 | vg(0 | (zA = 0 | vg(0 | v, 0 | U, 0 | S, 0 | zA)), 0 | o(), 0 | M, 0 | VA)), 0 | o(), 0 | Y, 0 | qA)), 0 | o(), 0 | TA, 0 | CA)), 0 | o(), 0 | iA, 0 | EA), iA = 0 | o(), AA = 0 | Ug(0 | gA, 0 | nA, -67108864 & eA | 0, 0 | AA), eA = 0 | o(), gA = 0 | ig(0 | (nA = 0 | vg(0 | hA, 0 | aA, 16777216, 0)), 0 | o(), 25), CA = 0 | o(), CA = 0 | vg(0 | (QA = 0 | vg(0 | (LA = 0 | vg(0 | (xA = 0 | vg(0 | (KA = 0 | vg(0 | jA, 0 | XA, 0 | d, 0 | KA)), 0 | o(), 0 | G, 0 | xA)), 0 | o(), 0 | _, 0 | LA)), 0 | o(), 0 | rA, 0 | QA)), 0 | o(), 0 | gA, 0 | CA), gA = 0 | o(), nA = 0 | Ug(0 | hA, 0 | aA, -33554432 & nA | 0, 0), aA = 0 | o(), QA = 0 | ig(0 | (hA = 0 | vg(0 | EA, 0 | iA, 16777216, 0)), 0 | o(), 25), rA = 0 | o(), rA = 0 | vg(0 | (IA = 0 | vg(0 | (JA = 0 | vg(0 | (RA = 0 | vg(0 | (NA = 0 | vg(0 | (mA = 0 | vg(0 | l, 0 | k, 0 | H, 0 | mA)), 0 | o(), 0 | u, 0 | NA)), 0 | o(), 0 | p, 0 | RA)), 0 | o(), 0 | PA, 0 | JA)), 0 | o(), 0 | I, 0 | IA)), 0 | o(), 0 | QA, 0 | rA), QA = 0 | o(), hA = 0 | Ug(0 | EA, 0 | iA, -33554432 & hA | 0, 0), iA = 0 | o(), IA = 0 | ig(0 | (EA = 0 | vg(0 | CA, 0 | gA, 33554432, 0)), 0 | o(), 26), I = 0 | o(), I = 0 | vg(0 | (BA = 0 | vg(0 | (SA = 0 | vg(0 | (UA = 0 | vg(0 | bA, 0 | vA, 0 | F, 0 | UA)), 0 | o(), 0 | D, 0 | SA)), 0 | o(), 0 | MA, 0 | BA)), 0 | o(), 0 | IA, 0 | I), IA = 0 | o(), EA = 0 | Ug(0 | CA, 0 | gA, -67108864 & EA | 0, 0), o(), CA = 0 | ig(0 | (gA = 0 | vg(0 | rA, 0 | QA, 33554432, 0)), 0 | o(), 26), BA = 0 | o(), BA = 0 | vg(0 | (lA = 0 | vg(0 | (GA = 0 | vg(0 | (dA = 0 | vg(0 | (YA = 0 | vg(0 | h, 0 | s, 0 | y, 0 | YA)), 0 | o(), 0 | w, 0 | dA)), 0 | o(), 0 | f, 0 | GA)), 0 | o(), 0 | _A, 0 | lA)), 0 | o(), 0 | CA, 0 | BA), CA = 0 | o(), gA = 0 | Ug(0 | rA, 0 | QA, -67108864 & gA | 0, 0), o(), eA = 0 | vg(0 | (rA = 0 | ig(0 | (QA = 0 | vg(0 | I, 0 | IA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | AA, 0 | eA), AA = 0 | o(), QA = 0 | Ug(0 | I, 0 | IA, -33554432 & QA | 0, 0), o(), I = 0 | ig(0 | (IA = 0 | vg(0 | BA, 0 | CA, 16777216, 0)), 0 | o(), 25), rA = 0 | o(), rA = 0 | vg(0 | (DA = 0 | vg(0 | (pA = 0 | vg(0 | (uA = 0 | vg(0 | (HA = 0 | vg(0 | (kA = 0 | vg(0 | t, 0 | r, 0 | n, 0 | kA)), 0 | o(), 0 | a, 0 | HA)), 0 | o(), 0 | c, 0 | uA)), 0 | o(), 0 | e, 0 | pA)), 0 | o(), 0 | FA, 0 | DA)), 0 | o(), 0 | I, 0 | rA), I = 0 | o(), IA = 0 | Ug(0 | BA, 0 | CA, -33554432 & IA | 0, 0), o(), BA = 0 | vg(0 | hA, 0 | iA, 0 | (BA = 0 | yg(0 | (CA = 0 | vg(0 | eA, 0 | AA, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), CA = 0 | Ug(0 | eA, 0 | AA, -67108864 & CA | 0, 0), o(), eA = 0 | ig(0 | (AA = 0 | vg(0 | rA, 0 | I, 33554432, 0)), 0 | o(), 26), iA = 0 | o(), iA = 0 | vg(0 | (tA = 0 | vg(0 | (wA = 0 | vg(0 | (yA = 0 | vg(0 | (sA = 0 | vg(0 | i, 0 | E, 0 | Q, 0 | sA)), 0 | o(), 0 | B, 0 | yA)), 0 | o(), 0 | g, 0 | wA)), 0 | o(), 0 | fA, 0 | tA)), 0 | o(), 0 | eA, 0 | iA), eA = 0 | o(), AA = 0 | Ug(0 | rA, 0 | I, -67108864 & AA | 0, 0), o(), cA = 0 | vg(0 | (rA = 0 | Qg(0 | (rA = 0 | ig(0 | (I = 0 | vg(0 | iA, 0 | eA, 16777216, 0)), 0 | o(), 25)), 0 | o(), 19, 0)), 0 | o(), 0 | oA, 0 | cA), oA = 0 | o(), I = 0 | Ug(0 | iA, 0 | eA, -33554432 & I | 0, 0), o(), iA = 0 | vg(0 | nA, 0 | aA, 0 | (iA = 0 | yg(0 | (eA = 0 | vg(0 | cA, 0 | oA, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), eA = 0 | Ug(0 | cA, 0 | oA, -67108864 & eA | 0, 0), o(), C[A >> 2] = eA, C[A + 4 >> 2] = iA, C[A + 8 >> 2] = EA, C[A + 12 >> 2] = QA, C[A + 16 >> 2] = CA, C[A + 20 >> 2] = BA, C[A + 24 >> 2] = gA, C[A + 28 >> 2] = IA, C[A + 32 >> 2] = AA, C[A + 36 >> 2] = I;
          }

          function G(A, I, g, B, C) {
            A |= 0, I |= 0, g |= 0, B |= 0;
            var E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0;
            if (n = 0 | qI(C |= 0), t = 0 | o(), E = 0 | qI(C + 8 | 0), i = 0 | o(), B = 0 | rg(0 | g, 0 | B, 56), C = 0 | o(), (I + g + (0 - (7 & g)) | 0) == (0 | I)) y = 2037671283 ^ E, e = 1952801890 ^ i, w = 1886610805 ^ n, r = 1936682341 ^ t, a = 1852075885 ^ E, c = 1685025377 ^ i, F = 1852142177 ^ n, E = 1819895653 ^ t, i = I;else for (D = 2037671283 ^ E, e = 1952801890 ^ i, y = 1886610805 ^ n, r = 1936682341 ^ t, a = 1852075885 ^ E, c = 1685025377 ^ i, i = 1852142177 ^ n, E = 1819895653 ^ t, w = I;;) {
              if (u = (s = 0 | qI(w)) ^ D, e ^= h = 0 | o(), F = 0 | vg(0 | y, 0 | r, 0 | a, 0 | c), D = 0 | o(), n = 0 | $I(a, c, 13), a = (0 | o()) ^ D, c = 0 | $I(F, D, 32), D = 0 | o(), t = 0 | vg(0 | u, 0 | e, 0 | i, 0 | E), f = 0 | o(), D = 0 | vg((e = 0 | $I(u, e, 16)) ^ t | 0, 0 | (i = (0 | o()) ^ f), 0 | c, 0 | D), c = 0 | o(), i = 0 | $I(e ^ t, i, 21), e = c ^ (0 | o()), f = 0 | vg(0 | t, 0 | f, n ^ F | 0, 0 | a), t = 0 | o(), a = 0 | $I(n ^ F, a, 17), E = (0 | o()) ^ t, t = 0 | $I(f, t, 32), F = 0 | o(), c = 0 | vg(a ^ f | 0, 0 | E, 0 | D, 0 | c), n = 0 | o(), E = 0 | $I(a ^ f, E, 13), f = (0 | o()) ^ n, n = 0 | $I(c, n, 32), a = 0 | o(), F = 0 | vg(0 | t, 0 | F, D ^ i | 0, 0 | e), t = 0 | o(), a = 0 | vg((e = 0 | $I(D ^ i, e, 16)) ^ F | 0, 0 | (i = (0 | o()) ^ t), 0 | n, 0 | a), n = 0 | o(), i = 0 | $I(e ^ F, i, 21), e = n ^ (0 | o()), t = 0 | vg(E ^ c | 0, 0 | f, 0 | F, 0 | t), F = 0 | o(), f = 0 | $I(E ^ c, f, 17), c = (0 | o()) ^ F, F = 0 | $I(t, F, 32), E = 0 | o(), (0 | (w = w + 8 | 0)) == (I + g + (0 - (7 & g)) | 0)) {
                y = a ^ i, w = a ^ s, r = n ^ h, a = f ^ t, i = I + g + (0 - (7 & g)) | 0;
                break;
              }

              D = a ^ i, y = a ^ s, r = n ^ h, a = f ^ t, i = F;
            }

            switch (7 & g) {
              case 7:
                p = 0 | rg(0 | Q[i + 6 >> 0], 0, 48), C = 0 | o() | C, B |= p, p = 6;
                break;

              case 6:
                p = 6;
                break;

              case 5:
                p = 7;
                break;

              case 4:
                p = 8;
                break;

              case 3:
                p = 9;
                break;

              case 2:
                p = 10;
                break;

              case 1:
                p = 11;
            }

            6 == (0 | p) && (u = 0 | rg(0 | Q[i + 5 >> 0], 0, 40), C = 0 | o() | C, B |= u, p = 7), 7 == (0 | p) && (C = 0 | Q[i + 4 >> 0] | C, p = 8), 8 == (0 | p) && (B |= u = 0 | rg(0 | Q[i + 3 >> 0], 0, 24), C = 0 | o() | C, p = 9), 9 == (0 | p) && (B |= u = 0 | rg(0 | Q[i + 2 >> 0], 0, 16), C = 0 | o() | C, p = 10), 10 == (0 | p) && (B |= u = 0 | rg(0 | Q[i + 1 >> 0], 0, 8), C = 0 | o() | C, p = 11), 11 == (0 | p) && (B = 0 | B | Q[i >> 0]), g = B ^ y, h = C ^ e, w = 0 | vg(0 | w, 0 | r, 0 | a, 0 | c), y = 0 | o(), s = 0 | $I(a, c, 13), I = (0 | o()) ^ y, y = 0 | $I(w, y, 32), p = 0 | o(), F = 0 | vg(0 | g, 0 | h, 0 | F, 0 | E), u = 0 | o(), p = 0 | vg((h = 0 | $I(g, h, 16)) ^ F | 0, 0 | (g = (0 | o()) ^ u), 0 | y, 0 | p), y = 0 | o(), g = 0 | $I(h ^ F, g, 21), h = y ^ (0 | o()), u = 0 | vg(0 | F, 0 | u, s ^ w | 0, 0 | I), F = 0 | o(), I = 0 | $I(s ^ w, I, 17), w = (0 | o()) ^ F, F = 0 | $I(u, F, 32), s = 0 | o(), y = 0 | vg(I ^ u | 0, 0 | w, 0 | p, 0 | y), D = 0 | o(), w = 0 | $I(I ^ u, w, 13), u = (0 | o()) ^ D, D = 0 | $I(y, D, 32), I = 0 | o(), s = 0 | vg(0 | F, 0 | s, p ^ g | 0, 0 | h), F = 0 | o(), I = 0 | vg((h = 0 | $I(p ^ g, h, 16)) ^ s | 0, 0 | (g = (0 | o()) ^ F), 0 | D, 0 | I), D = 0 | o(), g = 0 | $I(h ^ s, g, 21), h = D ^ (0 | o()), F = 0 | vg(w ^ y | 0, 0 | u, 0 | s, 0 | F), s = 0 | o(), u = 0 | $I(w ^ y, u, 17), y = (0 | o()) ^ s, s = 0 | $I(F, s, 32), w = 0 | o(), D = 0 | vg(I ^ B | 0, D ^ C | 0, u ^ F | 0, 0 | y), p = 0 | o(), y = 0 | $I(u ^ F, y, 13), F = (0 | o()) ^ p, p = 0 | $I(D, p, 32), u = 0 | o(), w = 0 | vg(255 ^ s | 0, 0 | w, I ^ g | 0, 0 | h), s = 0 | o(), u = 0 | vg((h = 0 | $I(I ^ g, h, 16)) ^ w | 0, 0 | (g = (0 | o()) ^ s), 0 | p, 0 | u), p = 0 | o(), g = 0 | $I(h ^ w, g, 21), h = p ^ (0 | o()), s = 0 | vg(0 | w, 0 | s, y ^ D | 0, 0 | F), w = 0 | o(), F = 0 | $I(y ^ D, F, 17), D = (0 | o()) ^ w, w = 0 | $I(s, w, 32), y = 0 | o(), p = 0 | vg(F ^ s | 0, 0 | D, 0 | u, 0 | p), I = 0 | o(), D = 0 | $I(F ^ s, D, 13), s = (0 | o()) ^ I, I = 0 | $I(p, I, 32), F = 0 | o(), y = 0 | vg(0 | w, 0 | y, u ^ g | 0, 0 | h), w = 0 | o(), F = 0 | vg((h = 0 | $I(u ^ g, h, 16)) ^ y | 0, 0 | (g = (0 | o()) ^ w), 0 | I, 0 | F), I = 0 | o(), g = 0 | $I(h ^ y, g, 21), h = I ^ (0 | o()), w = 0 | vg(D ^ p | 0, 0 | s, 0 | y, 0 | w), y = 0 | o(), s = 0 | $I(D ^ p, s, 17), p = (0 | o()) ^ y, y = 0 | $I(w, y, 32), D = 0 | o(), I = 0 | vg(s ^ w | 0, 0 | p, 0 | F, 0 | I), u = 0 | o(), p = 0 | $I(s ^ w, p, 13), w = (0 | o()) ^ u, u = 0 | $I(I, u, 32), s = 0 | o(), D = 0 | vg(0 | y, 0 | D, F ^ g | 0, 0 | h), y = 0 | o(), s = 0 | vg((h = 0 | $I(F ^ g, h, 16)) ^ D | 0, 0 | (g = (0 | o()) ^ y), 0 | u, 0 | s), u = 0 | o(), g = 0 | $I(h ^ D, g, 21), h = u ^ (0 | o()), y = 0 | vg(p ^ I | 0, 0 | w, 0 | D, 0 | y), D = 0 | o(), w = 0 | $I(p ^ I, w, 17), I = (0 | o()) ^ D, D = 0 | $I(y, D, 32), p = 0 | o(), u = 0 | vg(w ^ y | 0, 0 | I, 0 | s, 0 | u), F = 0 | o(), I = 0 | $I(w ^ y, I, 13), F = (0 | o()) ^ F, p = 0 | vg(0 | D, 0 | p, s ^ g | 0, 0 | h), D = 0 | o(), h = 0 | $I((h = 0 | $I(s ^ g, h, 16)) ^ p, (0 | o()) ^ D, 21), g = 0 | o(), D = 0 | vg(I ^ u | 0, 0 | F, 0 | p, 0 | D), p = 0 | o(), F = 0 | $I(I ^ u, F, 17), u = 0 | o(), LI(A, h ^ D ^ F ^ (I = 0 | $I(D, p, 32)), g ^ p ^ u ^ (0 | o()));
          }

          function d(A) {
            var I = 0,
                g = 0,
                B = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                o = 0,
                c = 0;

            if (A |= 0) {
              I = 0 | C[8683], c = A + -8 + (-8 & (g = 0 | C[A + -4 >> 2])) | 0;

              do {
                if (1 & g) e = A + -8 | 0, o = A + -8 | 0, A = -8 & g;else {
                  if (B = 0 | C[A + -8 >> 2], !(3 & g)) return;
                  if (i = B + (-8 & g) | 0, (E = A + -8 + (0 - B) | 0) >>> 0 < I >>> 0) return;

                  if ((0 | C[8684]) == (0 | E)) {
                    if (3 != (3 & (A = 0 | C[c + 4 >> 2]) | 0)) {
                      e = E, o = E, A = i;
                      break;
                    }

                    return C[8681] = i, C[c + 4 >> 2] = -2 & A, C[E + 4 >> 2] = 1 | i, void (C[E + i >> 2] = i);
                  }

                  if (B >>> 0 < 256) {
                    if (A = 0 | C[E + 8 >> 2], (0 | (I = 0 | C[E + 12 >> 2])) == (0 | A)) {
                      C[8679] = C[8679] & ~(1 << (B >>> 3)), e = E, o = E, A = i;
                      break;
                    }

                    C[A + 12 >> 2] = I, C[I + 8 >> 2] = A, e = E, o = E, A = i;
                    break;
                  }

                  Q = 0 | C[E + 24 >> 2], A = 0 | C[E + 12 >> 2];

                  do {
                    if ((0 | A) == (0 | E)) {
                      if (A = 0 | C[E + 16 + 4 >> 2]) I = E + 16 + 4 | 0;else {
                        if (!(A = 0 | C[E + 16 >> 2])) {
                          A = 0;
                          break;
                        }

                        I = E + 16 | 0;
                      }

                      for (;;) {
                        if (g = 0 | C[(B = A + 20 | 0) >> 2]) A = g, I = B;else {
                          if (!(g = 0 | C[(B = A + 16 | 0) >> 2])) break;
                          A = g, I = B;
                        }
                      }

                      C[I >> 2] = 0;
                    } else o = 0 | C[E + 8 >> 2], C[o + 12 >> 2] = A, C[A + 8 >> 2] = o;
                  } while (0);

                  if (Q) {
                    if (I = 0 | C[E + 28 >> 2], (0 | C[35020 + (I << 2) >> 2]) == (0 | E)) {
                      if (C[35020 + (I << 2) >> 2] = A, !A) {
                        C[8680] = C[8680] & ~(1 << I), e = E, o = E, A = i;
                        break;
                      }
                    } else if (C[((0 | C[Q + 16 >> 2]) == (0 | E) ? Q + 16 | 0 : Q + 20 | 0) >> 2] = A, !A) {
                      e = E, o = E, A = i;
                      break;
                    }

                    C[A + 24 >> 2] = Q, 0 | (I = 0 | C[E + 16 >> 2]) && (C[A + 16 >> 2] = I, C[I + 24 >> 2] = A), (I = 0 | C[E + 16 + 4 >> 2]) ? (C[A + 20 >> 2] = I, C[I + 24 >> 2] = A, e = E, o = E, A = i) : (e = E, o = E, A = i);
                  } else e = E, o = E, A = i;
                }
              } while (0);

              if (!(e >>> 0 >= c >>> 0) && 1 & (g = 0 | C[c + 4 >> 2])) {
                if (2 & g) C[c + 4 >> 2] = -2 & g, C[o + 4 >> 2] = 1 | A, C[e + A >> 2] = A, Q = A;else {
                  if ((0 | C[8685]) == (0 | c)) {
                    if (c = (0 | C[8682]) + A | 0, C[8682] = c, C[8685] = o, C[o + 4 >> 2] = 1 | c, (0 | o) != (0 | C[8684])) return;
                    return C[8684] = 0, void (C[8681] = 0);
                  }

                  if ((0 | C[8684]) == (0 | c)) return c = (0 | C[8681]) + A | 0, C[8681] = c, C[8684] = e, C[o + 4 >> 2] = 1 | c, void (C[e + c >> 2] = c);
                  Q = (-8 & g) + A | 0;

                  do {
                    if (g >>> 0 < 256) {
                      if (I = 0 | C[c + 8 >> 2], (0 | (A = 0 | C[c + 12 >> 2])) == (0 | I)) {
                        C[8679] = C[8679] & ~(1 << (g >>> 3));
                        break;
                      }

                      C[I + 12 >> 2] = A, C[A + 8 >> 2] = I;
                      break;
                    }

                    E = 0 | C[c + 24 >> 2], A = 0 | C[c + 12 >> 2];

                    do {
                      if ((0 | A) == (0 | c)) {
                        if (A = 0 | C[c + 16 + 4 >> 2]) I = c + 16 + 4 | 0;else {
                          if (!(A = 0 | C[c + 16 >> 2])) {
                            I = 0;
                            break;
                          }

                          I = c + 16 | 0;
                        }

                        for (;;) {
                          if (g = 0 | C[(B = A + 20 | 0) >> 2]) A = g, I = B;else {
                            if (!(g = 0 | C[(B = A + 16 | 0) >> 2])) break;
                            A = g, I = B;
                          }
                        }

                        C[I >> 2] = 0, I = A;
                      } else I = 0 | C[c + 8 >> 2], C[I + 12 >> 2] = A, C[A + 8 >> 2] = I, I = A;
                    } while (0);

                    if (0 | E) {
                      if (A = 0 | C[c + 28 >> 2], (0 | C[35020 + (A << 2) >> 2]) == (0 | c)) {
                        if (C[35020 + (A << 2) >> 2] = I, !I) {
                          C[8680] = C[8680] & ~(1 << A);
                          break;
                        }
                      } else if (C[((0 | C[E + 16 >> 2]) == (0 | c) ? E + 16 | 0 : E + 20 | 0) >> 2] = I, !I) break;

                      C[I + 24 >> 2] = E, 0 | (A = 0 | C[c + 16 >> 2]) && (C[I + 16 >> 2] = A, C[A + 24 >> 2] = I), 0 | (A = 0 | C[c + 16 + 4 >> 2]) && (C[I + 20 >> 2] = A, C[A + 24 >> 2] = I);
                    }
                  } while (0);

                  if (C[o + 4 >> 2] = 1 | Q, C[e + Q >> 2] = Q, (0 | o) == (0 | C[8684])) return void (C[8681] = Q);
                }
                if (g = Q >>> 3, Q >>> 0 < 256) return (A = 0 | C[8679]) & 1 << g ? (A = 34756 + (g << 1 << 2) + 8 | 0, I = 0 | C[34756 + (g << 1 << 2) + 8 >> 2]) : (C[8679] = A | 1 << g, A = 34756 + (g << 1 << 2) + 8 | 0, I = 34756 + (g << 1 << 2) | 0), C[A >> 2] = o, C[I + 12 >> 2] = o, C[o + 8 >> 2] = I, void (C[o + 12 >> 2] = 34756 + (g << 1 << 2));
                I = 35020 + ((B = (A = Q >>> 8) ? Q >>> 0 > 16777215 ? 31 : Q >>> (7 + (B = 14 - ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (A + 1048320 | 0) >>> 16 & 8 | (245760 + (B = A << ((A + 1048320 | 0) >>> 16 & 8) << ((520192 + (A << ((A + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (B << ((B + 245760 | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | B << 1 : 0) << 2) | 0, C[o + 28 >> 2] = B, C[o + 20 >> 2] = 0, C[o + 16 >> 2] = 0, A = 0 | C[8680], g = 1 << B;

                A: do {
                  if (A & g) {
                    A = 0 | C[I >> 2];

                    I: do {
                      if ((-8 & C[A + 4 >> 2] | 0) != (0 | Q)) {
                        for (B = Q << (31 == (0 | B) ? 0 : 25 - (B >>> 1) | 0); I = 0 | C[(g = A + 16 + (B >>> 31 << 2) | 0) >> 2];) {
                          if ((-8 & C[I + 4 >> 2] | 0) == (0 | Q)) {
                            A = I;
                            break I;
                          }

                          B <<= 1, A = I;
                        }

                        C[g >> 2] = o, C[o + 24 >> 2] = A, C[o + 12 >> 2] = o, C[o + 8 >> 2] = o;
                        break A;
                      }
                    } while (0);

                    c = 0 | C[(e = A + 8 | 0) >> 2], C[c + 12 >> 2] = o, C[e >> 2] = o, C[o + 8 >> 2] = c, C[o + 12 >> 2] = A, C[o + 24 >> 2] = 0;
                  } else C[8680] = A | g, C[I >> 2] = o, C[o + 24 >> 2] = I, C[o + 12 >> 2] = o, C[o + 8 >> 2] = o;
                } while (0);

                if (c = (0 | C[8687]) - 1 | 0, C[8687] = c, !(0 | c)) {
                  for (A = 35172; A = 0 | C[A >> 2];) {
                    A = A + 8 | 0;
                  }

                  C[8687] = -1;
                }
              }
            }
          }

          function Y(A, I) {
            I |= 0;
            var g = 0,
                B = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                o = 0;
            g = 0 | C[4 + (A |= 0) >> 2];

            do {
              if (1 & g) o = A, g = I;else {
                if (e = 0 | C[A >> 2], !(3 & g)) return;

                if ((0 | C[8684]) == (A + (0 - e) | 0)) {
                  if (3 != (3 & (g = 0 | C[A + I + 4 >> 2]) | 0)) {
                    o = A + (0 - e) | 0, g = e + I | 0;
                    break;
                  }

                  return C[8681] = e + I, C[A + I + 4 >> 2] = -2 & g, C[A + (0 - e) + 4 >> 2] = e + I | 1, void (C[A + I >> 2] = e + I);
                }

                if (e >>> 0 < 256) {
                  if (g = 0 | C[A + (0 - e) + 8 >> 2], (0 | (B = 0 | C[A + (0 - e) + 12 >> 2])) == (0 | g)) {
                    C[8679] = C[8679] & ~(1 << (e >>> 3)), o = A + (0 - e) | 0, g = e + I | 0;
                    break;
                  }

                  C[g + 12 >> 2] = B, C[B + 8 >> 2] = g, o = A + (0 - e) | 0, g = e + I | 0;
                  break;
                }

                i = 0 | C[A + (0 - e) + 24 >> 2], g = 0 | C[A + (0 - e) + 12 >> 2];

                do {
                  if ((0 | g) == (A + (0 - e) | 0)) {
                    if (g = 0 | C[4 + (B = A + (0 - e) + 16 | 0) >> 2]) B = B + 4 | 0;else if (!(g = 0 | C[B >> 2])) {
                      B = 0;
                      break;
                    }

                    for (;;) {
                      if (Q = 0 | C[(E = g + 20 | 0) >> 2]) g = Q, B = E;else {
                        if (!(Q = 0 | C[(E = g + 16 | 0) >> 2])) break;
                        g = Q, B = E;
                      }
                    }

                    C[B >> 2] = 0, B = g;
                  } else B = 0 | C[A + (0 - e) + 8 >> 2], C[B + 12 >> 2] = g, C[g + 8 >> 2] = B, B = g;
                } while (0);

                if (i) {
                  if (g = 0 | C[A + (0 - e) + 28 >> 2], (0 | C[35020 + (g << 2) >> 2]) == (A + (0 - e) | 0)) {
                    if (C[35020 + (g << 2) >> 2] = B, !B) {
                      C[8680] = C[8680] & ~(1 << g), o = A + (0 - e) | 0, g = e + I | 0;
                      break;
                    }
                  } else if (C[((0 | C[i + 16 >> 2]) == (A + (0 - e) | 0) ? i + 16 | 0 : i + 20 | 0) >> 2] = B, !B) {
                    o = A + (0 - e) | 0, g = e + I | 0;
                    break;
                  }

                  C[B + 24 >> 2] = i, 0 | (g = 0 | C[A + (0 - e) + 16 >> 2]) && (C[B + 16 >> 2] = g, C[g + 24 >> 2] = B), (g = 0 | C[A + (0 - e) + 16 + 4 >> 2]) ? (C[B + 20 >> 2] = g, C[g + 24 >> 2] = B, o = A + (0 - e) | 0, g = e + I | 0) : (o = A + (0 - e) | 0, g = e + I | 0);
                } else o = A + (0 - e) | 0, g = e + I | 0;
              }
            } while (0);

            if (2 & (Q = 0 | C[A + I + 4 >> 2])) C[A + I + 4 >> 2] = -2 & Q, C[o + 4 >> 2] = 1 | g, C[o + g >> 2] = g, i = g;else {
              if ((0 | C[8685]) == (A + I | 0)) {
                if (I = (0 | C[8682]) + g | 0, C[8682] = I, C[8685] = o, C[o + 4 >> 2] = 1 | I, (0 | o) != (0 | C[8684])) return;
                return C[8684] = 0, void (C[8681] = 0);
              }

              if ((0 | C[8684]) == (A + I | 0)) return I = (0 | C[8681]) + g | 0, C[8681] = I, C[8684] = o, C[o + 4 >> 2] = 1 | I, void (C[o + I >> 2] = I);
              i = (-8 & Q) + g | 0;

              do {
                if (Q >>> 0 < 256) {
                  if (B = 0 | C[A + I + 8 >> 2], (0 | (g = 0 | C[A + I + 12 >> 2])) == (0 | B)) {
                    C[8679] = C[8679] & ~(1 << (Q >>> 3));
                    break;
                  }

                  C[B + 12 >> 2] = g, C[g + 8 >> 2] = B;
                  break;
                }

                e = 0 | C[A + I + 24 >> 2], g = 0 | C[A + I + 12 >> 2];

                do {
                  if ((0 | g) == (A + I | 0)) {
                    if (g = 0 | C[A + I + 16 + 4 >> 2]) B = A + I + 16 + 4 | 0;else {
                      if (!(g = 0 | C[A + I + 16 >> 2])) {
                        B = 0;
                        break;
                      }

                      B = A + I + 16 | 0;
                    }

                    for (;;) {
                      if (Q = 0 | C[(E = g + 20 | 0) >> 2]) g = Q, B = E;else {
                        if (!(Q = 0 | C[(E = g + 16 | 0) >> 2])) break;
                        g = Q, B = E;
                      }
                    }

                    C[B >> 2] = 0, B = g;
                  } else B = 0 | C[A + I + 8 >> 2], C[B + 12 >> 2] = g, C[g + 8 >> 2] = B, B = g;
                } while (0);

                if (0 | e) {
                  if (g = 0 | C[A + I + 28 >> 2], (0 | C[35020 + (g << 2) >> 2]) == (A + I | 0)) {
                    if (C[35020 + (g << 2) >> 2] = B, !B) {
                      C[8680] = C[8680] & ~(1 << g);
                      break;
                    }
                  } else if (C[((0 | C[e + 16 >> 2]) == (A + I | 0) ? e + 16 | 0 : e + 20 | 0) >> 2] = B, !B) break;

                  C[B + 24 >> 2] = e, 0 | (g = 0 | C[A + I + 16 >> 2]) && (C[B + 16 >> 2] = g, C[g + 24 >> 2] = B), 0 | (g = 0 | C[A + I + 16 + 4 >> 2]) && (C[B + 20 >> 2] = g, C[g + 24 >> 2] = B);
                }
              } while (0);

              if (C[o + 4 >> 2] = 1 | i, C[o + i >> 2] = i, (0 | o) == (0 | C[8684])) return void (C[8681] = i);
            }
            if (Q = i >>> 3, i >>> 0 < 256) return (g = 0 | C[8679]) & 1 << Q ? (g = 34756 + (Q << 1 << 2) + 8 | 0, B = 0 | C[34756 + (Q << 1 << 2) + 8 >> 2]) : (C[8679] = g | 1 << Q, g = 34756 + (Q << 1 << 2) + 8 | 0, B = 34756 + (Q << 1 << 2) | 0), C[g >> 2] = o, C[B + 12 >> 2] = o, C[o + 8 >> 2] = B, void (C[o + 12 >> 2] = 34756 + (Q << 1 << 2));
            if (B = 35020 + ((E = (g = i >>> 8) ? i >>> 0 > 16777215 ? 31 : i >>> (7 + (E = 14 - ((520192 + (g << ((g + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4 | (g + 1048320 | 0) >>> 16 & 8 | (245760 + (E = g << ((g + 1048320 | 0) >>> 16 & 8) << ((520192 + (g << ((g + 1048320 | 0) >>> 16 & 8)) | 0) >>> 16 & 4)) | 0) >>> 16 & 2) + (E << ((E + 245760 | 0) >>> 16 & 2) >>> 15) | 0) | 0) & 1 | E << 1 : 0) << 2) | 0, C[o + 28 >> 2] = E, C[o + 20 >> 2] = 0, C[o + 16 >> 2] = 0, !((g = 0 | C[8680]) & (Q = 1 << E))) return C[8680] = g | Q, C[B >> 2] = o, C[o + 24 >> 2] = B, C[o + 12 >> 2] = o, void (C[o + 8 >> 2] = o);
            g = 0 | C[B >> 2];

            A: do {
              if ((-8 & C[g + 4 >> 2] | 0) != (0 | i)) {
                for (E = i << (31 == (0 | E) ? 0 : 25 - (E >>> 1) | 0); B = 0 | C[(Q = g + 16 + (E >>> 31 << 2) | 0) >> 2];) {
                  if ((-8 & C[B + 4 >> 2] | 0) == (0 | i)) {
                    g = B;
                    break A;
                  }

                  E <<= 1, g = B;
                }

                return C[Q >> 2] = o, C[o + 24 >> 2] = g, C[o + 12 >> 2] = o, void (C[o + 8 >> 2] = o);
              }
            } while (0);

            I = 0 | C[(A = g + 8 | 0) >> 2], C[I + 12 >> 2] = o, C[A >> 2] = o, C[o + 8 >> 2] = I, C[o + 12 >> 2] = g, C[o + 24 >> 2] = 0;
          }

          function M(A, I, g, Q, E) {
            A |= 0, I |= 0, g |= 0;
            var i,
                e,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0,
                m = 0,
                L = 0,
                x = 0,
                K = 0,
                X = 0,
                j = 0,
                T = 0,
                q = 0,
                V = 0,
                z = 0,
                W = 0,
                O = 0,
                Z = 0,
                $ = 0,
                AA = 0,
                IA = 0,
                gA = 0,
                BA = 0,
                CA = 0,
                QA = 0,
                EA = 0,
                iA = 0,
                eA = 0,
                oA = 0,
                cA = 0,
                aA = 0,
                nA = 0,
                rA = 0;

            if (e = y, i = y = y + 63 & -64, y = y + 64 | 0, !(0 == (0 | (Q |= 0)) & 0 == (0 | (E |= 0)))) {
              for (L = 0 | C[A >> 2], x = 0 | C[A + 4 >> 2], K = 0 | C[A + 8 >> 2], X = 0 | C[A + 12 >> 2], j = 0 | C[A + 16 >> 2], S = 0 | C[A + 20 >> 2], U = 0 | C[A + 24 >> 2], v = 0 | C[A + 28 >> 2], b = 0 | C[A + 32 >> 2], J = 0 | C[A + 36 >> 2], P = 0 | C[A + 40 >> 2], R = 0 | C[A + 44 >> 2], N = 0 | C[A + 56 >> 2], m = 0 | C[A + 60 >> 2], a = 0, Y = 0 | C[A + 48 >> 2], M = 0 | C[A + 52 >> 2], n = I;;) {
                if (d = E >>> 0 < 0 | 0 == (0 | E) & Q >>> 0 < 64) {
                  c = (I = i) + 64 | 0;

                  do {
                    C[I >> 2] = 0, I = I + 4 | 0;
                  } while ((0 | I) < (0 | c));

                  I = 0;

                  do {
                    B[i + I >> 0] = 0 | B[n + I >> 0], I = I + 1 | 0;
                  } while (E >>> 0 > 0 | 0 == (0 | E) & Q >>> 0 > I >>> 0);

                  G = i, a = g, n = i;
                } else G = g;

                g = 20, I = L, c = x, r = P, t = R, f = Y, w = M, s = N, h = m, D = K, F = X, p = j, u = S, H = U, k = v, l = b, _ = J;

                do {
                  W = 0 | wB((AA = 0 | wB((nA = 0 | wB(($ = (AA = 0 | wB((aA = I + p | 0) ^ f, 16)) + l | 0) ^ p, 12)) + aA ^ AA, 8)) + $ ^ nA, 7), rA = 0 | wB((V = 0 | wB((eA = 0 | wB((q = (V = 0 | wB((iA = c + u | 0) ^ w, 16)) + _ | 0) ^ u, 12)) + iA ^ V, 8)) + q ^ eA, 7), oA = 0 | wB((z = 0 | wB((BA = 0 | wB((IA = (z = 0 | wB((gA = D + H | 0) ^ s, 16)) + r | 0) ^ H, 12)) + gA ^ z, 8)) + IA ^ BA, 7), CA = 0 | wB((QA = 0 | wB((Z = 0 | wB((T = (QA = 0 | wB((O = F + k | 0) ^ h, 16)) + t | 0) ^ k, 12)) + O ^ QA, 8)) + T ^ Z, 7), u = 0 | wB((r = (h = 0 | wB((I = (EA = 0 | wB((cA = 0 | wB(QA ^ rA + (nA + aA), 16)) + (z + IA) ^ rA, 12)) + (rA + (nA + aA)) | 0) ^ cA, 8)) + (cA + (z + IA)) | 0) ^ EA, 7), H = 0 | wB((t = (f = 0 | wB((c = (IA = 0 | wB((EA = 0 | wB(oA + (eA + iA) ^ AA, 16)) + (QA + T) ^ oA, 12)) + (oA + (eA + iA)) | 0) ^ EA, 8)) + (EA + (QA + T)) | 0) ^ IA, 7), k = 0 | wB((l = (w = 0 | wB((D = (T = 0 | wB((IA = 0 | wB(CA + (BA + gA) ^ V, 16)) + (AA + $) ^ CA, 12)) + (CA + (BA + gA)) | 0) ^ IA, 8)) + (IA + (AA + $)) | 0) ^ T, 7), p = 0 | wB((_ = (s = 0 | wB((F = (T = 0 | wB((z = 0 | wB(Z + O + W ^ z, 16)) + (V + q) ^ W, 12)) + (Z + O + W) | 0) ^ z, 8)) + (z + (V + q)) | 0) ^ T, 7), g = g + -2 | 0;
                } while (0 != (0 | g));

                if (Z = (0 | Vg(n)) ^ I + L, $ = (0 | Vg(n + 4 | 0)) ^ c + x, AA = (0 | Vg(n + 8 | 0)) ^ D + K, IA = (0 | Vg(n + 12 | 0)) ^ F + X, gA = (0 | Vg(n + 16 | 0)) ^ p + j, BA = (0 | Vg(n + 20 | 0)) ^ u + S, CA = (0 | Vg(n + 24 | 0)) ^ H + U, QA = (0 | Vg(n + 28 | 0)) ^ k + v, EA = (0 | Vg(n + 32 | 0)) ^ l + b, iA = (0 | Vg(n + 36 | 0)) ^ _ + J, eA = (0 | Vg(n + 40 | 0)) ^ r + P, oA = (0 | Vg(n + 44 | 0)) ^ t + R, cA = (0 | Vg(n + 48 | 0)) ^ f + Y, aA = (0 | Vg(n + 52 | 0)) ^ w + M, nA = (0 | Vg(n + 56 | 0)) ^ s + N, rA = (0 | Vg(n + 60 | 0)) ^ h + m, c = M + (0 == (0 | (I = Y + 1 | 0)) & 1) | 0, Pg(G, Z), Pg(G + 4 | 0, $), Pg(G + 8 | 0, AA), Pg(G + 12 | 0, IA), Pg(G + 16 | 0, gA), Pg(G + 20 | 0, BA), Pg(G + 24 | 0, CA), Pg(G + 28 | 0, QA), Pg(G + 32 | 0, EA), Pg(G + 36 | 0, iA), Pg(G + 40 | 0, eA), Pg(G + 44 | 0, oA), Pg(G + 48 | 0, cA), Pg(G + 52 | 0, aA), Pg(G + 56 | 0, nA), Pg(G + 60 | 0, rA), E >>> 0 < 0 | 0 == (0 | E) & Q >>> 0 < 65) break;
                g = 0 | vg(0 | Q, 0 | E, -64, -1), E = 0 | o(), Q = g, g = G + 64 | 0, Y = I, M = c, n = n + 64 | 0;
              }

              if (d && 0 | Q) {
                E = 0;

                do {
                  B[a + E >> 0] = 0 | B[G + E >> 0], E = E + 1 | 0;
                } while ((0 | E) != (0 | Q));
              }

              C[A + 48 >> 2] = I, C[A + 52 >> 2] = c;
            }

            y = e;
          }

          function S(A, I, g, Q) {
            I |= 0, g |= 0, Q |= 0;
            var E,
                i,
                e,
                c,
                a,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0;
            if (a = 0 == (0 | B[80 + (A |= 0) >> 0]) ? 16777216 : 0, E = 0 | C[A + 4 >> 2], i = 0 | C[A + 8 >> 2], e = 0 | C[A + 12 >> 2], c = 0 | C[A + 16 >> 2], w = 0 | C[A + 20 >> 2], f = 0 | C[A + 24 >> 2], t = 0 | C[A + 28 >> 2], r = 0 | C[A + 32 >> 2], n = 0 | C[A + 36 >> 2], Q >>> 0 > 0 | 0 == (0 | Q) & g >>> 0 > 15) for (D = 0 | C[A >> 2];;) {
              if (k = (67108863 & (0 | Vg(I))) + w | 0, l = ((0 | Vg(I + 3 | 0)) >>> 2 & 67108863) + f | 0, H = ((0 | Vg(I + 6 | 0)) >>> 4 & 67108863) + t | 0, u = ((0 | Vg(I + 9 | 0)) >>> 6) + r | 0, w = ((0 | Vg(I + 12 | 0)) >>> 8 | a) + n | 0, n = 0 | Qg(0 | k, 0, 0 | D, 0), y = 0 | o(), t = 0 | vg(0 | (y = 0 | vg(0 | (t = 0 | vg(0 | (y = 0 | vg(0 | (t = 0 | Qg(0 | l, 0, 5 * c | 0, 0)), 0 | o(), 0 | n, 0 | y)), 0 | (n = 0 | o()), 0 | (t = 0 | Qg(0 | H, 0, 5 * e | 0, 0)), 0 | o())), 0 | (n = 0 | o()), 0 | (y = 0 | Qg(0 | u, 0, 5 * i | 0, 0)), 0 | o())), 0 | (n = 0 | o()), 0 | (t = 0 | Qg(0 | w, 0, 5 * E | 0, 0)), 0 | o()), n = 0 | o(), y = 0 | Qg(0 | k, 0, 0 | E, 0), s = 0 | o(), p = 0 | vg(0 | (s = 0 | vg(0 | (p = 0 | vg(0 | (s = 0 | vg(0 | (p = 0 | Qg(0 | l, 0, 0 | D, 0)), 0 | o(), 0 | y, 0 | s)), 0 | (y = 0 | o()), 0 | (p = 0 | Qg(0 | H, 0, 5 * c | 0, 0)), 0 | o())), 0 | (y = 0 | o()), 0 | (s = 0 | Qg(0 | u, 0, 5 * e | 0, 0)), 0 | o())), 0 | (y = 0 | o()), 0 | (p = 0 | Qg(0 | w, 0, 5 * i | 0, 0)), 0 | o()), y = 0 | o(), s = 0 | Qg(0 | k, 0, 0 | i, 0), h = 0 | o(), F = 0 | vg(0 | (h = 0 | vg(0 | (F = 0 | vg(0 | (h = 0 | vg(0 | (F = 0 | Qg(0 | l, 0, 0 | E, 0)), 0 | o(), 0 | s, 0 | h)), 0 | (s = 0 | o()), 0 | (F = 0 | Qg(0 | H, 0, 0 | D, 0)), 0 | o())), 0 | (s = 0 | o()), 0 | (h = 0 | Qg(0 | u, 0, 5 * c | 0, 0)), 0 | o())), 0 | (s = 0 | o()), 0 | (F = 0 | Qg(0 | w, 0, 5 * e | 0, 0)), 0 | o()), s = 0 | o(), h = 0 | Qg(0 | k, 0, 0 | e, 0), r = 0 | o(), f = 0 | vg(0 | (r = 0 | vg(0 | (f = 0 | vg(0 | (r = 0 | vg(0 | (f = 0 | Qg(0 | l, 0, 0 | i, 0)), 0 | o(), 0 | h, 0 | r)), 0 | (h = 0 | o()), 0 | (f = 0 | Qg(0 | H, 0, 0 | E, 0)), 0 | o())), 0 | (h = 0 | o()), 0 | (r = 0 | Qg(0 | u, 0, 0 | D, 0)), 0 | o())), 0 | (h = 0 | o()), 0 | (f = 0 | Qg(0 | w, 0, 5 * c | 0, 0)), 0 | o()), h = 0 | o(), r = 0 | Qg(0 | k, 0, 0 | c, 0), k = 0 | o(), w = 0 | vg(0 | (u = 0 | vg(0 | (H = 0 | vg(0 | (k = 0 | vg(0 | (l = 0 | Qg(0 | l, 0, 0 | e, 0)), 0 | o(), 0 | r, 0 | k)), 0 | (r = 0 | o()), 0 | (H = 0 | Qg(0 | H, 0, 0 | i, 0)), 0 | o())), 0 | (r = 0 | o()), 0 | (u = 0 | Qg(0 | u, 0, 0 | E, 0)), 0 | o())), 0 | (r = 0 | o()), 0 | (w = 0 | Qg(0 | w, 0, 0 | D, 0)), 0 | o()), r = 0 | o(), n = 0 | yg(0 | t, 0 | n, 26), o(), y = 0 | yg(0 | (n = 0 | vg(0 | p, 0 | y, 0 | n, 0)), 0 | o(), 26), o(), s = 0 | yg(0 | (y = 0 | vg(0 | F, 0 | s, 0 | y, 0)), 0 | o(), 26), o(), h = 0 | yg(0 | (s = 0 | vg(0 | f, 0 | h, 0 | s, 0)), 0 | o(), 26), o(), r = 0 | yg(0 | (h = 0 | vg(0 | w, 0 | r, 0 | h, 0)), 0 | o(), 26), o(), g = 0 | vg(0 | g, 0 | Q, -16, -1), !((Q = 0 | o()) >>> 0 > 0 | 0 == (0 | Q) & g >>> 0 > 15)) {
                g = (5 * r | 0) + (67108863 & t) & 67108863, f = (((5 * r | 0) + (67108863 & t) | 0) >>> 26) + (67108863 & n) | 0, t = 67108863 & y, r = 67108863 & s, n = 67108863 & h;
                break;
              }

              w = (5 * r | 0) + (67108863 & t) & 67108863, f = (((5 * r | 0) + (67108863 & t) | 0) >>> 26) + (67108863 & n) | 0, t = 67108863 & y, r = 67108863 & s, n = 67108863 & h, I = I + 16 | 0;
            } else g = w;
            C[A + 20 >> 2] = g, C[A + 24 >> 2] = f, C[A + 28 >> 2] = t, C[A + 32 >> 2] = r, C[A + 36 >> 2] = n;
          }

          function U(A, I) {
            A |= 0;
            var g = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0;
            a = 0 | kI(I |= 0), c = 0 | o(), u = 0 | rg(0 | (u = 0 | Bg(0 | B[I + 4 >> 0], 0 | B[I + 5 >> 0], 0 | B[I + 6 >> 0])), 0 | o(), 6), H = 0 | o(), e = 0 | rg(0 | (e = 0 | Bg(0 | B[I + 7 >> 0], 0 | B[I + 8 >> 0], 0 | B[I + 9 >> 0])), 0 | o(), 5), i = 0 | o(), F = 0 | rg(0 | (F = 0 | Bg(0 | B[I + 10 >> 0], 0 | B[I + 11 >> 0], 0 | B[I + 12 >> 0])), 0 | o(), 3), p = 0 | o(), E = 0 | rg(0 | (E = 0 | Bg(0 | B[I + 13 >> 0], 0 | B[I + 14 >> 0], 0 | B[I + 15 >> 0])), 0 | o(), 2), Q = 0 | o(), h = 0 | kI(I + 16 | 0), D = 0 | o(), n = 0 | rg(0 | (n = 0 | Bg(0 | B[I + 20 >> 0], 0 | B[I + 21 >> 0], 0 | B[I + 22 >> 0])), 0 | o(), 7), g = 0 | o(), r = 0 | rg(0 | (r = 0 | Bg(0 | B[I + 23 >> 0], 0 | B[I + 24 >> 0], 0 | B[I + 25 >> 0])), 0 | o(), 5), s = 0 | o(), t = 0 | rg(0 | (t = 0 | Bg(0 | B[I + 26 >> 0], 0 | B[I + 27 >> 0], 0 | B[I + 28 >> 0])), 0 | o(), 4), f = 0 | o(), w = 0 | rg(0 | (w = 0 | Bg(0 | B[I + 29 >> 0], 0 | B[I + 30 >> 0], 0 | B[I + 31 >> 0])), 0 | o(), 2), o(), k = 0 | Ug(0, 0, 0 | (k = 0 | yg(0 | (y = 0 | vg(33554428 & w | 0, 0, 16777216, 0)), 0 | o(), 25)), 0 | o()), o(), c = 0 | vg(19 & k | 0, 0, 0 | a, 0 | c), a = 0 | o(), y = 0 | Ug(33554428 & w | 0, 0, 33554432 & y | 0, 0), w = 0 | o(), i = 0 | vg(0 | (I = 0 | ig(0 | (k = 0 | vg(0 | u, 0 | H, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | e, 0 | i), e = 0 | o(), k = 0 | Ug(0 | u, 0 | H, -33554432 & k | 0, 0), H = 0 | o(), Q = 0 | vg(0 | (I = 0 | ig(0 | (u = 0 | vg(0 | F, 0 | p, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | E, 0 | Q), E = 0 | o(), u = 0 | Ug(0 | F, 0 | p, -33554432 & u | 0, 0), p = 0 | o(), I = 0 | vg(0 | n, 0 | g, 0 | (I = 0 | ig(0 | (F = 0 | vg(0 | h, 0 | D, 16777216, 0)), 0 | o(), 25)), 0 | o()), g = 0 | o(), F = 0 | Ug(0 | h, 0 | D, -33554432 & F | 0, 0), D = 0 | o(), f = 0 | vg(0 | (n = 0 | ig(0 | (h = 0 | vg(0 | r, 0 | s, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | t, 0 | f), t = 0 | o(), h = 0 | Ug(0 | r, 0 | s, -33554432 & h | 0, 0), s = 0 | o(), n = 0 | vg(0 | k, 0 | H, 0 | (n = 0 | yg(0 | (r = 0 | vg(0 | c, 0 | a, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), r = 0 | Ug(0 | c, 0 | a, -67108864 & r | 0, 0), o(), c = 0 | vg(0 | u, 0 | p, 0 | (c = 0 | yg(0 | (a = 0 | vg(0 | i, 0 | e, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), a = 0 | Ug(0 | i, 0 | e, -67108864 & a | 0, 0), o(), i = 0 | vg(0 | F, 0 | D, 0 | (i = 0 | yg(0 | (e = 0 | vg(0 | Q, 0 | E, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), e = 0 | Ug(0 | Q, 0 | E, -67108864 & e | 0, 0), o(), Q = 0 | vg(0 | h, 0 | s, 0 | (Q = 0 | yg(0 | (E = 0 | vg(0 | I, 0 | g, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), E = 0 | Ug(0 | I, 0 | g, -67108864 & E | 0, 0), o(), I = 0 | vg(0 | y, 0 | w, 0 | (I = 0 | yg(0 | (g = 0 | vg(0 | f, 0 | t, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), g = 0 | Ug(0 | f, 0 | t, -67108864 & g | 0, 0), o(), C[A >> 2] = r, C[A + 4 >> 2] = n, C[A + 8 >> 2] = a, C[A + 12 >> 2] = c, C[A + 16 >> 2] = e, C[A + 20 >> 2] = i, C[A + 24 >> 2] = E, C[A + 28 >> 2] = Q, C[A + 32 >> 2] = g, C[A + 36 >> 2] = I;
          }

          function v(A, I) {
            A |= 0;
            var g = 0,
                B = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0;
            c = 0 | C[(I |= 0) >> 2], p = 0 | C[I + 4 >> 2], i = 0 | C[I + 8 >> 2], D = 0 | C[I + 12 >> 2], Q = 0 | C[I + 16 >> 2], s = 0 | C[I + 20 >> 2], g = 0 | C[I + 24 >> 2], n = 0 | C[I + 28 >> 2], r = 0 | C[I + 32 >> 2], H = 0 | C[I + 36 >> 2], c = 0 | Qg(0 | c, ((0 | c) < 0) << 31 >> 31 | 0, 121666, 0), e = 0 | o(), p = 0 | Qg(0 | p, ((0 | p) < 0) << 31 >> 31 | 0, 121666, 0), u = 0 | o(), i = 0 | Qg(0 | i, ((0 | i) < 0) << 31 >> 31 | 0, 121666, 0), E = 0 | o(), D = 0 | Qg(0 | D, ((0 | D) < 0) << 31 >> 31 | 0, 121666, 0), F = 0 | o(), Q = 0 | Qg(0 | Q, ((0 | Q) < 0) << 31 >> 31 | 0, 121666, 0), B = 0 | o(), s = 0 | Qg(0 | s, ((0 | s) < 0) << 31 >> 31 | 0, 121666, 0), h = 0 | o(), g = 0 | Qg(0 | g, ((0 | g) < 0) << 31 >> 31 | 0, 121666, 0), I = 0 | o(), n = 0 | Qg(0 | n, ((0 | n) < 0) << 31 >> 31 | 0, 121666, 0), y = 0 | o(), r = 0 | Qg(0 | r, ((0 | r) < 0) << 31 >> 31 | 0, 121666, 0), t = 0 | o(), e = 0 | vg(0 | (a = 0 | Qg(0 | (a = 0 | ig(0 | (w = 0 | vg(0 | (H = 0 | Qg(0 | H, ((0 | H) < 0) << 31 >> 31 | 0, 121666, 0)), 0 | (f = 0 | o()), 16777216, 0)), 0 | o(), 25)), 0 | o(), 19, 0)), 0 | o(), 0 | c, 0 | e), c = 0 | o(), w = 0 | Ug(0 | H, 0 | f, -33554432 & w | 0, 0), f = 0 | o(), E = 0 | vg(0 | (a = 0 | ig(0 | (H = 0 | vg(0 | p, 0 | u, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | i, 0 | E), i = 0 | o(), H = 0 | Ug(0 | p, 0 | u, -33554432 & H | 0, 0), u = 0 | o(), B = 0 | vg(0 | (a = 0 | ig(0 | (p = 0 | vg(0 | D, 0 | F, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | Q, 0 | B), Q = 0 | o(), p = 0 | Ug(0 | D, 0 | F, -33554432 & p | 0, 0), F = 0 | o(), I = 0 | vg(0 | (a = 0 | ig(0 | (D = 0 | vg(0 | s, 0 | h, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | g, 0 | I), g = 0 | o(), D = 0 | Ug(0 | s, 0 | h, -33554432 & D | 0, 0), h = 0 | o(), t = 0 | vg(0 | (a = 0 | ig(0 | (s = 0 | vg(0 | n, 0 | y, 16777216, 0)), 0 | o(), 25)), 0 | o(), 0 | r, 0 | t), r = 0 | o(), s = 0 | Ug(0 | n, 0 | y, -33554432 & s | 0, 0), y = 0 | o(), a = 0 | vg(0 | H, 0 | u, 0 | (a = 0 | yg(0 | (n = 0 | vg(0 | e, 0 | c, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), n = 0 | Ug(0 | e, 0 | c, -67108864 & n | 0, 0), o(), e = 0 | vg(0 | p, 0 | F, 0 | (e = 0 | yg(0 | (c = 0 | vg(0 | E, 0 | i, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), c = 0 | Ug(0 | E, 0 | i, -67108864 & c | 0, 0), o(), E = 0 | vg(0 | D, 0 | h, 0 | (E = 0 | yg(0 | (i = 0 | vg(0 | B, 0 | Q, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), i = 0 | Ug(0 | B, 0 | Q, -67108864 & i | 0, 0), o(), B = 0 | vg(0 | s, 0 | y, 0 | (B = 0 | yg(0 | (Q = 0 | vg(0 | I, 0 | g, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), Q = 0 | Ug(0 | I, 0 | g, -67108864 & Q | 0, 0), o(), I = 0 | vg(0 | w, 0 | f, 0 | (I = 0 | yg(0 | (g = 0 | vg(0 | t, 0 | r, 33554432, 0)), 0 | o(), 26)), 0 | o()), o(), g = 0 | Ug(0 | t, 0 | r, -67108864 & g | 0, 0), o(), C[A >> 2] = n, C[A + 4 >> 2] = a, C[A + 8 >> 2] = c, C[A + 12 >> 2] = e, C[A + 16 >> 2] = i, C[A + 20 >> 2] = E, C[A + 24 >> 2] = Q, C[A + 28 >> 2] = B, C[A + 32 >> 2] = g, C[A + 36 >> 2] = I;
          }

          function b(A, I, g) {
            A |= 0, I |= 0;
            var C,
                E,
                i = 0,
                e = 0,
                o = 0;

            if (E = y, C = y = y + 63 & -64, y = y + 64 | 0, (g |= 0) << 24 >> 24 && (255 & g) <= 64) {
              if (0 | function (A, I) {
                return 1 & (0 != (0 | (A |= 0)) | 0 != (0 | (I |= 0))) | 0;
              }(Q[A + 80 >> 0] | Q[A + 80 + 1 >> 0] << 8 | Q[A + 80 + 2 >> 0] << 16 | Q[A + 80 + 3 >> 0] << 24, Q[A + 80 + 4 >> 0] | Q[A + 80 + 4 + 1 >> 0] << 8 | Q[A + 80 + 4 + 2 >> 0] << 16 | Q[A + 80 + 4 + 3 >> 0] << 24)) i = -1;else {
                i = Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24;

                do {
                  if (i >>> 0 > 128) {
                    if (aA(A, 128, 0), s(A, A + 96 | 0), i = (Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24) - 128 | 0, B[A + 352 >> 0] = i, B[A + 352 + 1 >> 0] = i >> 8, B[A + 352 + 2 >> 0] = i >> 16, B[A + 352 + 3 >> 0] = i >> 24, i >>> 0 < 129) {
                      BA(A + 96 | 0, A + 224 | 0, 0 | i), e = Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24, o = A + 96 | 0;
                      break;
                    }

                    c(33456, 33488, 306, 33533);
                  } else e = i, o = A + 96 | 0;
                } while (0);

                aA(A, e, 0), function (A) {
                  0 | B[356 + (A |= 0) >> 0] && function (A) {
                    B[88 + (A |= 0) >> 0] = -1, B[A + 88 + 1 >> 0] = -1, B[A + 88 + 2 >> 0] = -1, B[A + 88 + 3 >> 0] = -1, B[A + 88 + 4 >> 0] = -1, B[A + 88 + 4 + 1 >> 0] = -1, B[A + 88 + 4 + 2 >> 0] = -1, B[A + 88 + 4 + 3 >> 0] = -1;
                  }(A), B[A + 80 >> 0] = -1, B[A + 80 + 1 >> 0] = -1, B[A + 80 + 2 >> 0] = -1, B[A + 80 + 3 >> 0] = -1, B[A + 80 + 4 >> 0] = -1, B[A + 80 + 4 + 1 >> 0] = -1, B[A + 80 + 4 + 2 >> 0] = -1, B[A + 80 + 4 + 3 >> 0] = -1;
                }(A), YA(A + 96 + (i = Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24) | 0, 0, 256 - i | 0), s(A, o), LI(C, Q[A >> 0] | Q[A + 1 >> 0] << 8 | Q[A + 2 >> 0] << 16 | Q[A + 3 >> 0] << 24, Q[A + 4 >> 0] | Q[A + 4 + 1 >> 0] << 8 | Q[A + 4 + 2 >> 0] << 16 | Q[A + 4 + 3 >> 0] << 24), LI(C + 8 | 0, Q[A + 8 >> 0] | Q[A + 8 + 1 >> 0] << 8 | Q[A + 8 + 2 >> 0] << 16 | Q[A + 8 + 3 >> 0] << 24, Q[A + 8 + 4 >> 0] | Q[A + 8 + 4 + 1 >> 0] << 8 | Q[A + 8 + 4 + 2 >> 0] << 16 | Q[A + 8 + 4 + 3 >> 0] << 24), LI(C + 16 | 0, Q[A + 16 >> 0] | Q[A + 16 + 1 >> 0] << 8 | Q[A + 16 + 2 >> 0] << 16 | Q[A + 16 + 3 >> 0] << 24, Q[A + 16 + 4 >> 0] | Q[A + 16 + 4 + 1 >> 0] << 8 | Q[A + 16 + 4 + 2 >> 0] << 16 | Q[A + 16 + 4 + 3 >> 0] << 24), LI(C + 24 | 0, Q[A + 24 >> 0] | Q[A + 24 + 1 >> 0] << 8 | Q[A + 24 + 2 >> 0] << 16 | Q[A + 24 + 3 >> 0] << 24, Q[A + 24 + 4 >> 0] | Q[A + 24 + 4 + 1 >> 0] << 8 | Q[A + 24 + 4 + 2 >> 0] << 16 | Q[A + 24 + 4 + 3 >> 0] << 24), LI(C + 32 | 0, Q[A + 32 >> 0] | Q[A + 32 + 1 >> 0] << 8 | Q[A + 32 + 2 >> 0] << 16 | Q[A + 32 + 3 >> 0] << 24, Q[A + 32 + 4 >> 0] | Q[A + 32 + 4 + 1 >> 0] << 8 | Q[A + 32 + 4 + 2 >> 0] << 16 | Q[A + 32 + 4 + 3 >> 0] << 24), LI(C + 40 | 0, Q[A + 40 >> 0] | Q[A + 40 + 1 >> 0] << 8 | Q[A + 40 + 2 >> 0] << 16 | Q[A + 40 + 3 >> 0] << 24, Q[A + 40 + 4 >> 0] | Q[A + 40 + 4 + 1 >> 0] << 8 | Q[A + 40 + 4 + 2 >> 0] << 16 | Q[A + 40 + 4 + 3 >> 0] << 24), LI(C + 48 | 0, Q[A + 48 >> 0] | Q[A + 48 + 1 >> 0] << 8 | Q[A + 48 + 2 >> 0] << 16 | Q[A + 48 + 3 >> 0] << 24, Q[A + 48 + 4 >> 0] | Q[A + 48 + 4 + 1 >> 0] << 8 | Q[A + 48 + 4 + 2 >> 0] << 16 | Q[A + 48 + 4 + 3 >> 0] << 24), LI(C + 56 | 0, Q[A + 56 >> 0] | Q[A + 56 + 1 >> 0] << 8 | Q[A + 56 + 2 >> 0] << 16 | Q[A + 56 + 3 >> 0] << 24, Q[A + 56 + 4 >> 0] | Q[A + 56 + 4 + 1 >> 0] << 8 | Q[A + 56 + 4 + 2 >> 0] << 16 | Q[A + 56 + 4 + 3 >> 0] << 24), BA(0 | I, 0 | C, 255 & g | 0), MI(A, 64), MI(o, 256), i = 0;
              }
              return y = E, 0 | i;
            }

            return SB(), 0;
          }

          function J(A, I, g, Q) {
            A |= 0, I |= 0, g |= 0;
            var E,
                i,
                e = 0,
                o = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0;

            switch (i = y, E = y = y + 63 & -64, y = y + 16 | 0, 0 | (Q |= 0)) {
              case 2:
                if (I >>> 0 < 13) Q = -31;else {
                  e = 33688, o = (Q = A) + 13 | 0;

                  do {
                    B[Q >> 0] = 0 | B[e >> 0], Q = Q + 1 | 0, e = e + 1 | 0;
                  } while ((0 | Q) < (0 | o));

                  A = A + 12 | 0, o = I + -12 | 0, e = 6;
                }
                break;

              case 1:
                if (I >>> 0 < 12) Q = -31;else {
                  e = 33701, o = (Q = A) + 12 | 0;

                  do {
                    B[Q >> 0] = 0 | B[e >> 0], Q = Q + 1 | 0, e = e + 1 | 0;
                  } while ((0 | Q) < (0 | o));

                  A = A + 11 | 0, o = I + -11 | 0, e = 6;
                }
                break;

              default:
                Q = -31;
            }

            do {
              if (6 == (0 | e) && !(Q = 0 | oA(g))) {
                if (cI(E, 19), e = A + (Q = 0 | ZA(E)) | 0, a = o - Q | 0, o >>> 0 <= Q >>> 0) {
                  Q = -31;
                  break;
                }

                if (BA(0 | A, 0 | E, Q + 1 | 0), a >>> 0 >= 4) {
                  if (B[e >> 0] = 36, B[e + 1 >> 0] = 109, B[e + 2 >> 0] = 61, B[e + 3 >> 0] = 0, cI(E, 0 | C[g + 44 >> 2]), o = e + 3 + (A = 0 | ZA(E)) | 0, (a + -3 | 0) >>> 0 <= A >>> 0) {
                    Q = -31;
                    break;
                  }

                  if (BA(e + 3 | 0, 0 | E, A + 1 | 0), (a + -3 - A | 0) >>> 0 >= 4) {
                    if (B[o >> 0] = 44, B[o + 1 >> 0] = 116, B[o + 2 >> 0] = 61, B[o + 3 >> 0] = 0, cI(E, 0 | C[g + 40 >> 2]), I = o + 3 + (Q = 0 | ZA(E)) | 0, c = a + -3 - A - 3 - Q | 0, (a + -3 - A - 3 | 0) >>> 0 <= Q >>> 0) {
                      Q = -31;
                      break;
                    }

                    if (BA(o + 3 | 0, 0 | E, Q + 1 | 0), c >>> 0 >= 4) {
                      if (B[I >> 0] = 44, B[I + 1 >> 0] = 112, B[I + 2 >> 0] = 61, B[I + 3 >> 0] = 0, cI(E, 0 | C[g + 48 >> 2]), (c + -3 | 0) >>> 0 <= (e = 0 | ZA(E)) >>> 0) {
                        Q = -31;
                        break;
                      }

                      if (BA(I + 3 | 0, 0 | E, e + 1 | 0), Q = I + 3 + e + 1 | 0, (c + -3 - e | 0) >>> 0 >= 2 && (B[I + 3 + e >> 0] = 36, B[I + 3 + e + 1 >> 0] = 0, q(Q, c + -3 - e - 1 | 0, 0 | C[g + 16 >> 2], 0 | C[g + 20 >> 2], 3), (r = c + -3 - e - 1 - (n = 0 | ZA(Q)) | 0) >>> 0 >= 2)) return B[Q + n >> 0] = 36, B[Q + n + 1 >> 0] = 0, q(Q + n + 1 | 0, r + -1 | 0, 0 | C[g >> 2], 0 | C[g + 4 >> 2], 3), y = i, 0;
                      Q = -31;
                    } else Q = -31;
                  } else Q = -31;
                } else Q = -31;
              }
            } while (0);

            return y = i, 0 | Q;
          }

          function P(A, I, g, Q) {
            A |= 0, I |= 0, g |= 0, Q |= 0;
            var E,
                i,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0;
            i = y, E = y = y + 63 & -64, y = y + 704 | 0;

            A: do {
              if (!(0 == (0 | g) & 0 == (0 | Q))) {
                if (r = 0 | yg(0 | (s = 0 | C[A + 72 >> 2]), 0 | (f = 0 | C[A + 72 + 4 >> 2]), 3), o(), t = 0 | rg(0 | g, 0 | Q, 3), w = 0 | o(), a = 0 | yg(0 | g, 0 | Q, 61), n = 0 | o(), f = 0 | vg(0 | s, 0 | f, 0 | t, 0 | w), s = 0 | o(), C[A + 72 >> 2] = f, C[A + 72 + 4 >> 2] = s, e = 0 | C[A + 64 >> 2], c = 0 | C[A + 64 + 4 >> 2], s >>> 0 < w >>> 0 | (0 | s) == (0 | w) & f >>> 0 < t >>> 0 && (e = 0 | vg(0 | e, 0 | c, 1, 0), c = 0 | o(), C[A + 64 >> 2] = e, C[A + 64 + 4 >> 2] = c), e = 0 | vg(0 | e, 0 | c, 0 | a, 0 | n), n = 0 | o(), C[A + 64 >> 2] = e, C[A + 64 + 4 >> 2] = n, n = 0 | Ug(128, 0, 127 & r | 0, 0), (e = 0 | o()) >>> 0 > Q >>> 0 | (0 | e) == (0 | Q) & n >>> 0 > g >>> 0) for (e = 0, c = 0;;) {
                  if (w = 0 | B[I + e >> 0], s = 0 | vg(0 | e, 0 | c, 127 & r | 0, 0), o(), B[A + 80 + s >> 0] = w, e = 0 | vg(0 | e, 0 | c, 1, 0), !((c = 0 | o()) >>> 0 < Q >>> 0 | (0 | c) == (0 | Q) & e >>> 0 < g >>> 0)) break A;
                }

                if (!(0 == (0 | n) & 0 == (0 | e))) {
                  c = 0, a = 0;

                  do {
                    w = 0 | B[I + c >> 0], s = 0 | vg(0 | c, 0 | a, 127 & r | 0, 0), o(), B[A + 80 + s >> 0] = w, c = 0 | vg(0 | c, 0 | a, 1, 0), a = 0 | o();
                  } while (a >>> 0 < e >>> 0 | (0 | a) == (0 | e) & c >>> 0 < n >>> 0);
                }

                if (D(A, A + 80 | 0, E, E + 640 | 0), e = 0 | Ug(0 | g, 0 | Q, 0 | n, 0 | e), (a = 0 | o()) >>> 0 > 0 | 0 == (0 | a) & e >>> 0 > 127) {
                  c = I + n | 0;

                  do {
                    D(A, c, E, E + 640 | 0), c = c + 128 | 0, e = 0 | vg(0 | e, 0 | a, -128, -1), a = 0 | o();
                  } while (a >>> 0 > 0 | 0 == (0 | a) & e >>> 0 > 127);
                } else c = I + n | 0;

                if (!(0 == (0 | (n = 127 & e)) & !0)) {
                  e = 0, a = 0;

                  do {
                    B[A + 80 + e >> 0] = 0 | B[c + e >> 0], e = 0 | vg(0 | e, 0 | a, 1, 0), a = 0 | o();
                  } while (a >>> 0 < 0 | 0 == (0 | a) & e >>> 0 < n >>> 0);
                }

                MI(E, 704);
              }
            } while (0);

            y = i;
          }

          function R(A, I, g) {
            A |= 0, I |= 0;
            var B = 0,
                C = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                o = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0,
                v = 0,
                b = 0,
                J = 0,
                P = 0,
                R = 0,
                N = 0;
            C = 0 | Vg(g |= 0), Q = 0 | Vg(g + 4 | 0), E = 0 | Vg(g + 8 | 0), i = 0 | Vg(g + 12 | 0), e = 0 | Vg(g + 16 | 0), o = 0 | Vg(g + 20 | 0), r = 0 | Vg(g + 24 | 0), t = 0 | Vg(g + 28 | 0), f = 0 | Vg(I), w = 0 | Vg(I + 4 | 0), y = 0 | Vg(I + 8 | 0), c = 0, a = 1634760805, n = 857760878, g = 0 | Vg(I + 12 | 0), I = 2036477234, B = 1797285236;

            do {
              p = 0 | wB((l = 0 | wB((R = 0 | wB((k = (l = 0 | wB(f ^ (P = C + a | 0), 16)) + e | 0) ^ C, 12)) + P ^ l, 8)) + k ^ R, 7), N = 0 | wB((D = 0 | wB((v = 0 | wB((h = (D = 0 | wB(w ^ (U = Q + n | 0), 16)) + o | 0) ^ Q, 12)) + U ^ D, 8)) + h ^ v, 7), b = 0 | wB((F = 0 | wB((d = 0 | wB((_ = (F = 0 | wB(y ^ (G = E + I | 0), 16)) + r | 0) ^ E, 12)) + G ^ F, 8)) + _ ^ d, 7), Y = 0 | wB((M = 0 | wB((H = 0 | wB((s = (M = 0 | wB(g ^ (u = i + B | 0), 16)) + t | 0) ^ i, 12)) + u ^ M, 8)) + s ^ H, 7), Q = 0 | wB((r = (g = 0 | wB((a = (S = 0 | wB((J = 0 | wB(M ^ N + (R + P), 16)) + (F + _) ^ N, 12)) + (N + (R + P)) | 0) ^ J, 8)) + (J + (F + _)) | 0) ^ S, 7), E = 0 | wB((t = (f = 0 | wB((n = (_ = 0 | wB((S = 0 | wB(b + (v + U) ^ l, 16)) + (M + s) ^ b, 12)) + (b + (v + U)) | 0) ^ S, 8)) + (S + (M + s)) | 0) ^ _, 7), i = 0 | wB((e = (w = 0 | wB((I = (s = 0 | wB((_ = 0 | wB(Y + (d + G) ^ D, 16)) + (l + k) ^ Y, 12)) + (Y + (d + G)) | 0) ^ _, 8)) + (_ + (l + k)) | 0) ^ s, 7), C = 0 | wB((o = (y = 0 | wB((B = (s = 0 | wB((F = 0 | wB(H + u + p ^ F, 16)) + (D + h) ^ p, 12)) + (H + u + p) | 0) ^ F, 8)) + (F + (D + h)) | 0) ^ s, 7), c = c + 1 | 0;
            } while (10 != (0 | c));

            Pg(A, a), Pg(A + 4 | 0, n), Pg(A + 8 | 0, I), Pg(A + 12 | 0, B), Pg(A + 16 | 0, f), Pg(A + 20 | 0, w), Pg(A + 24 | 0, y), Pg(A + 28 | 0, g);
          }

          function N(A, I, g, C) {
            A |= 0, g |= 0, C |= 0;
            var Q,
                E,
                i = 0,
                e = 0;

            for (Q = y, E = y = y + 63 & -64, y = y + 2272 | 0, yA(E + 1536 | 0, I |= 0), yA(E + 1280 | 0, C), eg(E, g), og(E + 2112 | 0, g), Eg(E + 1792 | 0, E + 2112 | 0), gI(E + 2112 | 0, E + 1792 | 0, E), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 160 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 160 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 320 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 320 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 480 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 480 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 640 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 640 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 800 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 800 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 960 | 0, E + 1952 | 0), gI(E + 2112 | 0, E + 1792 | 0, E + 960 | 0), Eg(E + 1952 | 0, E + 2112 | 0), eg(E + 1120 | 0, E + 1952 | 0), function (A) {
              Kg(A |= 0), Sg(A + 40 | 0), Sg(A + 80 | 0);
            }(A), g = 255;;) {
              if (0 | B[E + 1536 + g >> 0]) {
                i = g, e = 5;
                break;
              }

              if (0 | B[E + 1280 + g >> 0]) {
                i = g, e = 5;
                break;
              }

              if (!g) break;
              g = g + -1 | 0;
            }

            if (5 == (0 | e) && (0 | i) > -1) for (; aI(E + 2112 | 0, A), (g = 0 | B[E + 1536 + i >> 0]) << 24 >> 24 <= 0 ? g << 24 >> 24 < 0 && (Eg(E + 1952 | 0, E + 2112 | 0), II(E + 2112 | 0, E + 1952 | 0, E + (160 * (((g << 24 >> 24) / -2 | 0) << 24 >> 24) | 0) | 0)) : (Eg(E + 1952 | 0, E + 2112 | 0), gI(E + 2112 | 0, E + 1952 | 0, E + (160 * ((255 & g) >>> 1 & 255) | 0) | 0)), (g = 0 | B[E + 1280 + i >> 0]) << 24 >> 24 <= 0 ? g << 24 >> 24 < 0 && (Eg(E + 1952 | 0, E + 2112 | 0), BI(E + 2112 | 0, E + 1952 | 0, 160 + (120 * (((g << 24 >> 24) / -2 | 0) << 24 >> 24) | 0) | 0)) : (Eg(E + 1952 | 0, E + 2112 | 0), CI(E + 2112 | 0, E + 1952 | 0, 160 + (120 * ((255 & g) >>> 1 & 255) | 0) | 0)), Hg(A, E + 2112 | 0), (0 | i) > 0;) {
              i = i + -1 | 0;
            }
            y = Q;
          }

          function m(A, I, g, Q, E, i, e, o) {
            A |= 0, I |= 0, g |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, o |= 0;
            var c,
                a,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                s = 0,
                h = 0;

            if (a = y, c = y = y + 63 & -64, y = y + 16 | 0, C[c >> 2] = 0, EB(o), Q) {
              f = 0, r = 0, t = 0, n = 0;

              A: for (;;) {
                for (s = n; n = 0 | B[g + s >> 0], 255 == (0 | (w = 4 & o ? 0 | VA(n) : 0 | zA(n)));) {
                  if (!E) {
                    w = 18;
                    break A;
                  }

                  if (!(0 | qg(E, n))) {
                    w = 19;
                    break A;
                  }

                  if (!((n = s + 1 | 0) >>> 0 < Q >>> 0)) {
                    w = 17;
                    break A;
                  }

                  s = n;
                }

                if (f = w + (f << 6) | 0, (n = r + 6 | 0) >>> 0 > 7) {
                  if (r = r + -2 | 0, t >>> 0 >= I >>> 0) {
                    w = 13;
                    break;
                  }

                  B[A + t >> 0] = f >>> r, t = t + 1 | 0;
                } else r = n;

                if ((n = s + 1 | 0) >>> 0 >= Q >>> 0) {
                  w = 16;
                  break;
                }
              }

              13 == (0 | w) ? (C[c >> 2] = s, C[8678] = 68, n = -1) : 16 == (0 | w) ? (C[c >> 2] = n, n = 0) : 17 == (0 | w) ? (C[c >> 2] = n, n = 0) : 18 == (0 | w) ? (C[c >> 2] = s, n = 0) : 19 == (0 | w) && (C[c >> 2] = s, n = 0), r >>> 0 > 4 ? (t = 0, n = -1) : w = 21;
            } else f = 0, r = 0, t = 0, n = 0, w = 21;

            do {
              if (21 == (0 | w)) if ((1 << r) - 1 & f) t = 0, n = -1;else if (n | 2 & o || (n = 0 | mA(g, Q, c, E, r >>> 1)), n) t = 0;else if (0 != (0 | E) && (h = 0 | C[c >> 2]) >>> 0 < Q >>> 0) {
                for (n = h;;) {
                  if (!(0 | qg(E, 0 | B[g + n >> 0]))) {
                    w = 31;
                    break;
                  }

                  if ((n = n + 1 | 0) >>> 0 >= Q >>> 0) {
                    w = 30;
                    break;
                  }
                }

                if (30 == (0 | w)) {
                  C[c >> 2] = n, n = 0;
                  break;
                }

                if (31 == (0 | w)) {
                  C[c >> 2] = n, n = 0;
                  break;
                }
              } else n = 0;
            } while (0);

            return r = 0 | C[c >> 2], e ? C[e >> 2] = g + r : (0 | r) != (0 | Q) && (C[8678] = 28, n = -1), 0 | i && (C[i >> 2] = t), y = a, 0 | n;
          }

          function L(A, I, g) {
            I |= 0, g |= 0;
            var Q,
                E,
                i,
                e = 0,
                o = 0,
                c = 0;

            switch (i = y, E = y = y + 63 & -64, y = y + 16 | 0, c = 0 | C[20 + (A |= 0) >> 2], Q = 0 | C[A + 4 >> 2], C[A + 20 >> 2] = 0, C[A + 4 >> 2] = 0, 0 | g) {
              case 2:
                0 | oI(I, 33653, 9) ? I = -32 : (I = I + 9 | 0, o = 4);
                break;

              case 1:
                0 | oI(I, 33663, 8) ? I = -32 : (I = I + 8 | 0, o = 4);
                break;

              default:
                I = -26;
            }

            do {
              if (4 == (0 | o)) if (0 == (0 | oI(I, 33672, 3)) && 0 != (0 | (e = 0 | qA(I + 3 | 0, E + 4 | 0)))) {
                if (19 == (0 | C[E + 4 >> 2])) {
                  if (0 | oI(e, 33676, 3)) I = -32;else {
                    if (!(I = 0 | qA(e + 3 | 0, E + 4 | 0))) {
                      I = -32;
                      break;
                    }

                    if (C[A + 44 >> 2] = C[E + 4 >> 2], 0 | oI(I, 33680, 3)) I = -32;else {
                      if (!(I = 0 | qA(I + 3 | 0, E + 4 | 0))) {
                        I = -32;
                        break;
                      }

                      if (C[A + 40 >> 2] = C[E + 4 >> 2], 0 | oI(I, 33684, 3)) I = -32;else {
                        if (!(I = 0 | qA(I + 3 | 0, E + 4 | 0))) {
                          I = -32;
                          break;
                        }

                        if (o = 0 | C[E + 4 >> 2], C[A + 48 >> 2] = o, C[A + 52 >> 2] = o, I = (o = 36 == (0 | B[I >> 0])) ? I + 1 | 0 : I, o) {
                          if (C[E + 4 >> 2] = c, 0 | m(o = 0 | C[A + 16 >> 2], c, I, 0 | ZA(I), 0, E + 4 | 0, E, 3)) {
                            I = -32;
                            break;
                          }

                          if (C[A + 20 >> 2] = C[E + 4 >> 2], I = 0 | C[E >> 2], I = (c = 36 == (0 | B[I >> 0])) ? I + 1 | 0 : I, c) {
                            if (C[E + 4 >> 2] = Q, 0 | m(c = 0 | C[A >> 2], Q, I, 0 | ZA(I), 0, E + 4 | 0, E, 3)) {
                              I = -32;
                              break;
                            }

                            C[A + 4 >> 2] = C[E + 4 >> 2], g = 0 | C[E >> 2], (I = 0 | oA(A)) || (I = 0 == (0 | B[g >> 0]) ? 0 : -32);
                          } else I = -32;
                        } else I = -32;
                      }
                    }
                  }
                } else I = -26;
              } else I = -32;
            } while (0);

            return y = i, 0 | I;
          }

          function x(A, I, g) {
            A |= 0, I |= 0;
            var B = 0,
                C = 0,
                Q = 0,
                E = 0,
                i = 0,
                e = 0,
                o = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0,
                s = 0,
                h = 0,
                D = 0,
                F = 0,
                p = 0,
                u = 0,
                H = 0,
                k = 0,
                l = 0,
                _ = 0,
                G = 0,
                d = 0,
                Y = 0,
                M = 0,
                S = 0,
                U = 0;
            Q = 0 | Vg(g |= 0), n = 0 | Vg(g + 4 | 0), r = 0 | Vg(g + 8 | 0), t = 0 | Vg(g + 12 | 0), i = 0 | Vg(g + 16 | 0), e = 0 | Vg(g + 20 | 0), o = 0 | Vg(g + 24 | 0), c = 0 | Vg(g + 28 | 0), w = 0 | Vg(I), y = 0 | Vg(I + 4 | 0), s = 0 | Vg(I + 8 | 0), B = 20, C = 1634760805, E = 2036477234, a = 1797285236, f = 857760878, g = 0 | Vg(I + 12 | 0);

            do {
              Y = (0 | wB((F = (0 | wB((H = (0 | wB((_ = (0 | wB(e + C | 0, 7)) ^ t) + C | 0, 9)) ^ s) + _ | 0, 13)) ^ e) + H | 0, 18)) ^ C, l = (0 | wB((U = (0 | wB((D = (0 | wB((u = (0 | wB(f + Q | 0, 7)) ^ g) + f | 0, 9)) ^ o) + u | 0, 13)) ^ Q) + D | 0, 18)) ^ f, p = (0 | wB((d = (0 | wB((S = (0 | wB((h = (0 | wB(E + w | 0, 7)) ^ c) + E | 0, 9)) ^ n) + h | 0, 13)) ^ w) + S | 0, 18)) ^ E, I = (0 | wB((k = (0 | wB((G = (0 | wB((M = (0 | wB(a + i | 0, 7)) ^ r) + a | 0, 9)) ^ y) + M | 0, 13)) ^ i) + G | 0, 18)) ^ a, C = (0 | wB((r = (0 | wB((n = (0 | wB((Q = (0 | wB(M + Y | 0, 7)) ^ U) + Y | 0, 9)) ^ S) + Q | 0, 13)) ^ M) + n | 0, 18)) ^ Y, f = (0 | wB((t = (0 | wB((y = (0 | wB((w = (0 | wB(l + _ | 0, 7)) ^ d) + l | 0, 9)) ^ G) + w | 0, 13)) ^ _) + y | 0, 18)) ^ l, E = (0 | wB((g = (0 | wB((s = (0 | wB((i = (0 | wB(p + u | 0, 7)) ^ k) + p | 0, 9)) ^ H) + i | 0, 13)) ^ u) + s | 0, 18)) ^ p, a = (0 | wB((c = (0 | wB((o = (0 | wB((e = (0 | wB(I + h | 0, 7)) ^ F) + I | 0, 9)) ^ D) + e | 0, 13)) ^ h) + o | 0, 18)) ^ I, B = B + -2 | 0;
            } while (0 != (0 | B));

            Pg(A, C), Pg(A + 4 | 0, f), Pg(A + 8 | 0, E), Pg(A + 12 | 0, a), Pg(A + 16 | 0, w), Pg(A + 20 | 0, y), Pg(A + 24 | 0, s), Pg(A + 28 | 0, g);
          }

          function K(A, I, g, Q) {
            I |= 0, g |= 0, Q |= 0;
            var E = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0;
            if (0 == (0 | (i = 0 | C[56 + (A |= 0) >> 2])) & 0 == (0 | (E = 0 | C[A + 56 + 4 >> 2]))) r = 7;else {
              if (c = 0 | Ug(16, 0, 0 | i, 0 | E), !(0 == (0 | (n = (a = 0 | o()) >>> 0 > Q >>> 0 | (0 | a) == (0 | Q) & c >>> 0 > g >>> 0 ? g : c)) & 0 == (0 | (a = a >>> 0 > Q >>> 0 | (0 | a) == (0 | Q) & c >>> 0 > g >>> 0 ? Q : a)))) {
                c = 0, e = 0;

                do {
                  t = 0 | B[I + c >> 0], i = 0 | vg(0 | i, 0 | E, 0 | c, 0 | e), o(), B[A + 64 + i >> 0] = t, c = 0 | vg(0 | c, 0 | e, 1, 0), e = 0 | o(), i = 0 | C[A + 56 >> 2], E = 0 | C[A + 56 + 4 >> 2];
                } while (e >>> 0 < a >>> 0 | (0 | e) == (0 | a) & c >>> 0 < n >>> 0);
              }

              t = 0 | vg(0 | i, 0 | E, 0 | n, 0 | a), c = 0 | o(), C[A + 56 >> 2] = t, C[A + 56 + 4 >> 2] = c, c >>> 0 < 0 | 0 == (0 | c) & t >>> 0 < 16 || (g = 0 | Ug(0 | g, 0 | Q, 0 | n, 0 | a), Q = 0 | o(), S(A, A + 64 | 0, 16, 0), C[A + 56 >> 2] = 0, C[A + 56 + 4 >> 2] = 0, I = I + n | 0, r = 7);
            }

            if (7 == (0 | r) && (E = -16 & g, Q >>> 0 > 0 | 0 == (0 | Q) & g >>> 0 > 15 ? (i = 0 | Ug(0 | g, 0 | Q, 0 | E, 0 | Q), t = 0 | o(), S(A, I, E, Q), Q = t, I = I + E | 0) : i = g, !(0 == (0 | i) & 0 == (0 | Q)))) {
              E = 0, g = 0;

              do {
                r = 0 | B[I + E >> 0], t = 0 | vg(0 | C[A + 56 >> 2], 0 | C[A + 56 + 4 >> 2], 0 | E, 0 | g), o(), B[A + 64 + t >> 0] = r, E = 0 | vg(0 | E, 0 | g, 1, 0), g = 0 | o();
              } while (g >>> 0 < Q >>> 0 | (0 | g) == (0 | Q) & E >>> 0 < i >>> 0);

              r = 0 | vg(0 | C[A + 56 >> 2], 0 | C[A + 56 + 4 >> 2], 0 | i, 0 | Q), t = 0 | o(), C[A + 56 >> 2] = r, C[A + 56 + 4 >> 2] = t;
            }
          }

          function X(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                i = 0,
                e = 0,
                c = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0,
                w = 0,
                y = 0;

            A: do {
              if (0 | A) {
                do {
                  if (2 == (0 | C[A + 36 >> 2])) {
                    if (0 == (0 | (g = 0 | C[I >> 2])) && (0 | Q[I + 8 >> 0]) <= 1) {
                      i = 6;
                      break;
                    }

                    t = 0 | C[A + 4 >> 2], r = 0;
                  } else i = 6;
                } while (0);

                if (6 == (0 | i) && (QA(A, I, t = 0 | C[A + 4 >> 2]), g = 0 | C[I >> 2], r = 1), g = 0 == (0 | g) & (e = 0 | B[I + 8 >> 0]) << 24 >> 24 == 0 ? 2 : 0, i = 0 | C[A + 24 >> 2], a = 0 | E(i, 0 | C[I + 4 >> 2]), n = 0 | C[A + 20 >> 2], e = a + g + (0 | E(n, 255 & e)) | 0, g >>> 0 < n >>> 0) for (c = i, n = e, i = (0 == (0 | (e >>> 0) % (i >>> 0)) ? i + -1 | 0 : -1) + e | 0;;) {
                  if (a = 1 == (0 | (n >>> 0) % (c >>> 0)) ? n + -1 | 0 : i, i = r ? t + (g << 3) | 0 : (0 | C[4 + (0 | C[A >> 2]) >> 2]) + (a << 10) | 0, y = 0 | C[(c = i) >> 2], c = 0 | Ag(0 | C[c + 4 >> 2], 0, 0 | C[A + 28 >> 2], 0), e = 0 | o(), f = 0 | C[I >> 2], i = 0 | B[I + 8 >> 0], w = 0 | C[I + 4 >> 2], c = 0 == (0 | f) & i << 24 >> 24 == 0 ? w : c, C[I + 12 >> 2] = g, e = 0 | DA(A, f, i, g, y, 1 & ((0 | c) == (0 | w) ? 0 == (0 | (0 == (0 | f) & i << 24 >> 24 == 0 ? 0 : e)) : 0)), e = (i = 0 | C[4 + (0 | C[A >> 2]) >> 2]) + ((0 | E(0 | C[A + 24 >> 2], c)) << 10) + (e << 10) | 0, c = i + (n << 10) | 0, f ? H(i + (a << 10) | 0, e, c) : k(i + (a << 10) | 0, e, c), (g = g + 1 | 0) >>> 0 >= (0 | C[A + 20 >> 2]) >>> 0) break A;
                  c = 0 | C[A + 24 >> 2], n = n + 1 | 0, i = a + 1 | 0;
                }
              }
            } while (0);
          }

          function j(A, I, g) {
            var B, Q;
            g |= 0, B = y, Q = y = y + 63 & -64, y = y + 400 | 0, 0 == (0 | (A |= 0)) | 0 == (0 | (I |= 0)) || (HI(Q, 0, 0, 64), Pg(Q + 384 | 0, 0 | C[I + 48 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, 0 | C[I + 4 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, 0 | C[I + 44 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, 0 | C[I + 40 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, 19), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, g), Xg(Q, Q + 384 | 0, 4, 0), Pg(Q + 384 | 0, 0 | C[I + 12 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), 0 | (g = 0 | C[I + 8 >> 2]) && (Xg(Q, g, 0 | C[I + 12 >> 2], 0), 1 & C[I + 56 >> 2] | 0) && (MI(0 | C[I + 8 >> 2], 0 | C[I + 12 >> 2]), C[I + 12 >> 2] = 0), Pg(Q + 384 | 0, 0 | C[I + 20 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), 0 | (g = 0 | C[I + 16 >> 2]) && Xg(Q, g, 0 | C[I + 20 >> 2], 0), Pg(Q + 384 | 0, 0 | C[I + 28 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), 0 | (g = 0 | C[I + 24 >> 2]) && (Xg(Q, g, 0 | C[I + 28 >> 2], 0), 2 & C[I + 56 >> 2] | 0) && (MI(0 | C[I + 24 >> 2], 0 | C[I + 28 >> 2]), C[I + 28 >> 2] = 0), Pg(Q + 384 | 0, 0 | C[I + 36 >> 2]), Xg(Q, Q + 384 | 0, 4, 0), 0 | (g = 0 | C[I + 32 >> 2]) && Xg(Q, g, 0 | C[I + 36 >> 2], 0), fg(Q, A, 64)), y = B;
          }

          function T(A, I, g, Q) {
            A |= 0, I |= 0, g |= 0, Q |= 0;
            var E,
                i,
                e = 0,
                o = 0,
                c = 0;
            if (E = y, i = y = y + 63 & -64, y = y + 528 | 0, C[i + 512 >> 2] = 0, Pg(i + 512 | 0, I), I >>> 0 < 65) (0 | HI(i, 0, 0, I)) >= 0 && (Xg(i, i + 512 | 0, 4, 0), Xg(i, g, Q, 0), fg(i, A, I));else A: do {
              if ((0 | HI(i, 0, 0, 64)) >= 0 && (Xg(i, i + 512 | 0, 4, 0), Xg(i, g, Q, 0), (0 | fg(i, i + 448 | 0, 64)) >= 0)) {
                o = i + 448 | 0, c = (e = A) + 32 | 0;

                do {
                  B[e >> 0] = 0 | B[o >> 0], e = e + 1 | 0, o = o + 1 | 0;
                } while ((0 | e) < (0 | c));

                o = i + 448 | 0, c = 64 + (e = i + 384 | 0) | 0;

                do {
                  C[e >> 2] = C[o >> 2], e = e + 4 | 0, o = o + 4 | 0;
                } while ((0 | e) < (0 | c));

                if ((I + -32 | 0) >>> 0 > 64) {
                  Q = A + 32 | 0, g = I + -32 | 0;

                  do {
                    if ((0 | TI(i + 448 | 0, 64, i + 384 | 0, 64, 0, 0, 0)) < 0) break A;
                    o = i + 448 | 0, c = (e = Q) + 32 | 0;

                    do {
                      B[e >> 0] = 0 | B[o >> 0], e = e + 1 | 0, o = o + 1 | 0;
                    } while ((0 | e) < (0 | c));

                    g = g + -32 | 0, Q = Q + 32 | 0, o = i + 448 | 0, c = 64 + (e = i + 384 | 0) | 0;

                    do {
                      C[e >> 2] = C[o >> 2], e = e + 4 | 0, o = o + 4 | 0;
                    } while ((0 | e) < (0 | c));
                  } while (g >>> 0 > 64);
                } else Q = A + 32 | 0, g = I + -32 | 0;

                (0 | TI(i + 448 | 0, g, i + 384 | 0, 64, 0, 0, 0)) >= 0 && BA(0 | Q, i + 448 | 0, 0 | g);
              }
            } while (0);
            MI(i, 384), y = E;
          }

          function q(A, I, g, C, i) {
            A |= 0, I |= 0, g |= 0, C |= 0;
            var e = 0,
                o = 0,
                a = 0,
                n = 0,
                r = 0,
                t = 0;
            EB(i |= 0), o = (0 | E((C >>> 0) / 3 | 0, -3)) + C | 0, e = ((C >>> 0) / 3 | 0) << 2;

            do {
              if (o) {
                if (2 & i) {
                  e = (2 | e) + (o >>> 1) | 0;
                  break;
                }

                e = e + 4 | 0;
                break;
              }
            } while (0);

            if (e >>> 0 >= I >>> 0 && SB(), 4 & i) {
              if (0 | C) {
                n = 0, i = 0, o = 0, r = 0;

                do {
                  if (t = r, r = r + 1 | 0, n = n << 8 | 0 | Q[g + t >> 0], (i = i + 8 | 0) >>> 0 > 5) for (;;) {
                    if (t = 255 & (0 | XI(n >>> (i = i + -6 | 0) & 63)), a = o + 1 | 0, B[A + o >> 0] = t, !(i >>> 0 > 5)) {
                      o = a;
                      break;
                    }

                    o = a;
                  }
                } while ((0 | r) != (0 | C));

                i && (t = 255 & (0 | XI(n << 6 - i & 63)), B[A + o >> 0] = t, o = o + 1 | 0);
              } else o = 0;
            } else if (0 | C) {
              n = 0, i = 0, o = 0, r = 0;

              do {
                if (a = r, r = r + 1 | 0, n = n << 8 | 0 | Q[g + a >> 0], (i = i + 8 | 0) >>> 0 > 5) for (;;) {
                  if (t = 255 & (0 | jI(n >>> (i = i + -6 | 0) & 63)), a = o + 1 | 0, B[A + o >> 0] = t, !(i >>> 0 > 5)) {
                    o = a;
                    break;
                  }

                  o = a;
                }
              } while ((0 | r) != (0 | C));

              i && (t = 255 & (0 | jI(n << 6 - i & 63)), B[A + o >> 0] = t, o = o + 1 | 0);
            } else o = 0;
            return e >>> 0 < o >>> 0 && c(34564, 34583, 230, 34599), e >>> 0 > o >>> 0 ? YA(A + o | 0, 61, e - o | 0) : e = o, YA(A + e | 0, 0, ((t = e + 1 | 0) >>> 0 < I >>> 0 ? I : t) - e | 0), 0 | A;
          }

          function V(A, I, g, E, i, e, c, a) {
            A |= 0, I |= 0, i |= 0, e |= 0, c |= 0, a |= 0;
            var n,
                r,
                t = 0,
                f = 0;

            if (n = y, r = y = y + 63 & -64, y = y + 112 | 0, !(0 == (0 | (g |= 0)) & 0 == (0 | (E |= 0)))) {
              t = (f = r) + 32 | 0;

              do {
                B[f >> 0] = 0 | B[a >> 0], f = f + 1 | 0, a = a + 1 | 0;
              } while ((0 | f) < (0 | t));

              a = Q[i + 4 >> 0] | Q[i + 4 + 1 >> 0] << 8 | Q[i + 4 + 2 >> 0] << 16 | Q[i + 4 + 3 >> 0] << 24, C[r + 96 >> 2] = Q[i >> 0] | Q[i + 1 >> 0] << 8 | Q[i + 2 >> 0] << 16 | Q[i + 3 >> 0] << 24, C[r + 96 + 4 >> 2] = a, a = 8;

              do {
                B[r + 96 + a >> 0] = e, e = 0 | yg(0 | e, 0 | c, 8), c = 0 | o(), a = a + 1 | 0;
              } while (16 != (0 | a));

              if (E >>> 0 > 0 | 0 == (0 | E) & g >>> 0 > 63) for (e = E;;) {
                iB(r + 32 | 0, r + 96 | 0, r), c = 0;

                do {
                  B[A + c >> 0] = B[r + 32 + c >> 0] ^ B[I + c >> 0], c = c + 1 | 0;
                } while (64 != (0 | c));

                for (a = 8, c = 1; c = c + (0 | Q[(E = r + 96 + a | 0) >> 0]) | 0, B[E >> 0] = c, 16 != (0 | (a = a + 1 | 0));) {
                  c >>>= 8;
                }

                if (c = 0 | vg(0 | g, 0 | e, -64, -1), A = A + 64 | 0, I = I + 64 | 0, !((a = 0 | o()) >>> 0 > 0 | 0 == (0 | a) & c >>> 0 > 63)) {
                  e = c;
                  break;
                }

                g = c, e = a;
              } else e = g, a = E;

              if (!(0 == (0 | e) & 0 == (0 | a)) && (iB(r + 32 | 0, r + 96 | 0, r), 0 | e)) {
                c = 0;

                do {
                  B[A + c >> 0] = B[r + 32 + c >> 0] ^ B[I + c >> 0], c = c + 1 | 0;
                } while ((0 | c) != (0 | e));
              }

              MI(r + 32 | 0, 64), MI(r, 32);
            }

            y = n;
          }

          function z(A, I) {
            I |= 0;
            var g,
                Q,
                E,
                i,
                e,
                c,
                a = 0,
                n = 0,
                r = 0,
                t = 0;
            0 == (0 | (n = 0 | C[56 + (A |= 0) >> 2])) & 0 == (0 | (a = 0 | C[A + 56 + 4 >> 2])) || (B[A + 64 + n >> 0] = 1, a = 0 | vg(0 | n, 0 | a, 1, 0), (r = 0 | o()) >>> 0 < 0 | 0 == (0 | r) & a >>> 0 < 16 && YA(A + 64 + a | 0, 0, 14 - n + 1 | 0), B[A + 80 >> 0] = 1, S(A, A + 64 | 0, 16, 0)), n = 0 | C[A + 24 >> 2], t = (E = (-67108864 | (Q = ((t = ((r = (0 | C[A + 28 >> 2]) + (n >>> 26) | 0) >>> 26) + (0 | C[A + 32 >> 2]) | 0) >>> 26) + (0 | C[A + 36 >> 2]) | 0)) + ((((((i = ((c = (5 * (Q >>> 26) | 0) + (0 | C[A + 20 >> 2]) | 0) >>> 26) + (67108863 & n) + ((5 + (67108863 & c) | 0) >>> 26) | 0) >>> 26) + (67108863 & r) | 0) >>> 26) + (67108863 & t) | 0) >>> 26) | 0) >> 31 & 67108863 & t | (e = (E >>> 31) - 1 & 67108863) & (((i >>> 26) + (67108863 & r) | 0) >>> 26) + (67108863 & t), g = 0 | vg(E >> 31 & 67108863 & c | e & 5 + (67108863 & c) | (E >> 31 & (c >>> 26) + (67108863 & n) | e & i) << 26 | 0, 0, 0 | C[A + 40 >> 2], 0), a = 0 | o(), a = 0 | vg(0 | (n = 0 | vg((E >> 31 & (c >>> 26) + (67108863 & n) | e & i) >>> 6 | (E >> 31 & 67108863 & r | e & (i >>> 26) + (67108863 & r)) << 20 | 0, 0, 0 | C[A + 44 >> 2], 0)), 0 | o(), 0 | a, 0), n = 0 | o(), n = 0 | vg(0 | (r = 0 | vg((E >> 31 & 67108863 & r | e & (i >>> 26) + (67108863 & r)) >>> 12 | t << 14 | 0, 0, 0 | C[A + 48 >> 2], 0)), 0 | o(), 0 | n, 0), r = 0 | o(), r = 0 | vg(0 | (t = 0 | vg(((E >>> 31) - 1 & E | E >> 31 & Q) << 8 | t >>> 18 | 0, 0, 0 | C[A + 52 >> 2], 0)), 0 | o(), 0 | r, 0), o(), Pg(I, g), Pg(I + 4 | 0, a), Pg(I + 8 | 0, n), Pg(I + 12 | 0, r), MI(A, 88);
          }

          function W(A, I) {
            var g, B;
            A |= 0, g = y, B = y = y + 63 & -64, y = y + 192 | 0, _(B + 144 | 0, I |= 0), _(B + 96 | 0, B + 144 | 0), _(B + 96 | 0, B + 96 | 0), u(B + 96 | 0, I, B + 96 | 0), u(B + 144 | 0, B + 144 | 0, B + 96 | 0), _(B + 48 | 0, B + 144 | 0), u(B + 96 | 0, B + 96 | 0, B + 48 | 0), _(B + 48 | 0, B + 96 | 0), I = 1;

            do {
              _(B + 48 | 0, B + 48 | 0), I = I + 1 | 0;
            } while (5 != (0 | I));

            u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 96 | 0), I = 1;

            do {
              _(B + 48 | 0, B + 48 | 0), I = I + 1 | 0;
            } while (10 != (0 | I));

            u(B + 48 | 0, B + 48 | 0, B + 96 | 0), _(B, B + 48 | 0), I = 1;

            do {
              _(B, B), I = I + 1 | 0;
            } while (20 != (0 | I));

            u(B + 48 | 0, B, B + 48 | 0), _(B + 48 | 0, B + 48 | 0), I = 1;

            do {
              _(B + 48 | 0, B + 48 | 0), I = I + 1 | 0;
            } while (10 != (0 | I));

            u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 96 | 0), I = 1;

            do {
              _(B + 48 | 0, B + 48 | 0), I = I + 1 | 0;
            } while (50 != (0 | I));

            u(B + 48 | 0, B + 48 | 0, B + 96 | 0), _(B, B + 48 | 0), I = 1;

            do {
              _(B, B), I = I + 1 | 0;
            } while (100 != (0 | I));

            u(B + 48 | 0, B, B + 48 | 0), _(B + 48 | 0, B + 48 | 0), I = 1;

            do {
              _(B + 48 | 0, B + 48 | 0), I = I + 1 | 0;
            } while (50 != (0 | I));

            u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 96 | 0, B + 96 | 0), I = 1;

            do {
              _(B + 96 | 0, B + 96 | 0), I = I + 1 | 0;
            } while (5 != (0 | I));

            u(A, B + 96 | 0, B + 144 | 0), y = g;
          }

          function O(A, I) {
            A |= 0;
            var g,
                C,
                Q = 0;

            for (g = y, C = y = y + 63 & -64, y = y + 1760 | 0, eg(C, I |= 0), og(C + 1600 | 0, I), Eg(C + 1280 | 0, C + 1600 | 0), gI(C + 1600 | 0, C + 1280 | 0, C), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 160 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 160 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 320 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 320 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 480 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 480 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 640 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 640 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 800 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 800 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 960 | 0, C + 1440 | 0), gI(C + 1600 | 0, C + 1280 | 0, C + 960 | 0), Eg(C + 1440 | 0, C + 1600 | 0), eg(C + 1120 | 0, C + 1440 | 0), Og(A), Q = 252; og(C + 1600 | 0, A), (I = 0 | B[31840 + Q >> 0]) << 24 >> 24 <= 0 ? I << 24 >> 24 < 0 && (Eg(C + 1440 | 0, C + 1600 | 0), II(C + 1600 | 0, C + 1440 | 0, C + (160 * (((I << 24 >> 24) / -2 | 0) << 24 >> 24) | 0) | 0)) : (Eg(C + 1440 | 0, C + 1600 | 0), gI(C + 1600 | 0, C + 1440 | 0, C + (160 * ((255 & I) >>> 1 & 255) | 0) | 0)), Eg(A, C + 1600 | 0), Q;) {
              Q = Q + -1 | 0;
            }

            y = g;
          }

          function Z(A, I, g, B, Q, E, i) {
            A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0;
            var e,
                c,
                a = 0,
                n = 0;
            return e = y, c = y = y + 63 & -64, y = y + 352 | 0, x(c, E |= 0, i |= 0), A >>> 0 > g >>> 0 && 0 < Q >>> 0 | 0 == (0 | Q) & (A - g | 0) >>> 0 < B >>> 0 ? n = 5 : g >>> 0 > A >>> 0 && 0 < Q >>> 0 | 0 == (0 | Q) & (g - A | 0) >>> 0 < B >>> 0 ? n = 5 : a = g, 5 == (0 | n) && (YI(0 | A, 0 | g, 0 | B), a = A), C[c + 32 >> 2] = 0, C[c + 32 + 4 >> 2] = 0, C[c + 32 + 8 >> 2] = 0, C[c + 32 + 12 >> 2] = 0, C[c + 32 + 16 >> 2] = 0, C[c + 32 + 20 >> 2] = 0, C[c + 32 + 24 >> 2] = 0, C[c + 32 + 28 >> 2] = 0, 0 == (0 | (i = Q >>> 0 > 0 | 0 == (0 | Q) & B >>> 0 > 32 ? 32 : B)) & 0 == (0 | (g = Q >>> 0 > 0 | 0 == (0 | Q) & B >>> 0 > 32 ? 0 : Q)) || BA(c + 32 + 32 | 0, 0 | a, -2 - (n = ~Q >>> 0 > 4294967295 | -1 == (0 | ~Q) & ~B >>> 0 > 4294967263 ? ~B : -33) + 1 | 0), Yg(c + 32 | 0, c + 32 | 0, n = 0 | vg(0 | i, 0 | g, 32, 0), 0 | o(), E + 16 | 0, c), gB(c + 96 | 0, c + 32 | 0), 0 == (0 | i) & 0 == (0 | g) || BA(0 | A, c + 32 + 32 | 0, -2 - (n = ~Q >>> 0 > 4294967295 | -1 == (0 | ~Q) & ~B >>> 0 > 4294967263 ? ~B : -33) + 1 | 0), MI(c + 32 | 0, 64), Q >>> 0 > 0 | 0 == (0 | Q) & B >>> 0 > 32 && _g(A + i | 0, a + i | 0, n = 0 | Ug(0 | B, 0 | Q, 0 | i, 0 | g), 0 | o(), E + 16 | 0, c), MI(c, 32), bg(c + 96 | 0, A, B, Q), IB(c + 96 | 0, I), MI(c + 96 | 0, 256), y = e, 0;
          }

          function $(A, I, g, C) {
            A |= 0, I |= 0, g |= 0, C |= 0;
            var E = 0,
                i = 0,
                e = 0,
                c = 0;

            A: do {
              if (!(0 == (0 | g) & 0 == (0 | C))) {
                for (E = Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24, e = I; I = A + 96 + E | 0, C >>> 0 > 0 | 0 == (0 | C) & g >>> 0 > (c = 256 - E | 0) >>> 0;) {
                  BA(0 | I, 0 | e, 0 | c), I = (Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24) + c | 0, B[A + 352 >> 0] = I, B[A + 352 + 1 >> 0] = I >> 8, B[A + 352 + 2 >> 0] = I >> 16, B[A + 352 + 3 >> 0] = I >> 24, aA(A, 128, 0), s(A, A + 96 | 0), E = A + 224 | 0, i = 128 + (I = A + 96 | 0) | 0;

                  do {
                    B[I >> 0] = 0 | B[E >> 0], I = I + 1 | 0, E = E + 1 | 0;
                  } while ((0 | I) < (0 | i));

                  if (E = (Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24) - 128 | 0, B[A + 352 >> 0] = E, B[A + 352 + 1 >> 0] = E >> 8, B[A + 352 + 2 >> 0] = E >> 16, B[A + 352 + 3 >> 0] = E >> 24, 0 == (0 | (g = 0 | Ug(0 | g, 0 | C, 0 | c, 0))) & 0 == (0 | (C = 0 | o()))) break A;
                  e = e + c | 0;
                }

                BA(0 | I, 0 | e, 0 | g), c = (Q[A + 352 >> 0] | Q[A + 352 + 1 >> 0] << 8 | Q[A + 352 + 2 >> 0] << 16 | Q[A + 352 + 3 >> 0] << 24) + g | 0, B[A + 352 >> 0] = c, B[A + 352 + 1 >> 0] = c >> 8, B[A + 352 + 2 >> 0] = c >> 16, B[A + 352 + 3 >> 0] = c >> 24;
              }
            } while (0);
          }

          function AA(A, I, g) {
            var B, Q, E, i, e, o, c, a, n, r, t, f, w, y, s, h, D, F, p, u;
            I |= 0, g |= 0, u = 0 | C[(A |= 0) >> 2], F = 0 | C[A + 4 >> 2], h = 0 | C[A + 8 >> 2], y = 0 | C[A + 12 >> 2], f = 0 | C[A + 16 >> 2], r = 0 | C[A + 20 >> 2], a = 0 | C[A + 24 >> 2], o = 0 | C[A + 28 >> 2], i = 0 | C[A + 32 >> 2], Q = 0 | C[A + 36 >> 2], p = 0 | C[I >> 2], D = 0 | C[I + 4 >> 2], s = 0 | C[I + 8 >> 2], w = 0 | C[I + 12 >> 2], t = 0 | C[I + 16 >> 2], n = 0 | C[I + 20 >> 2], c = 0 | C[I + 24 >> 2], e = 0 | C[I + 28 >> 2], E = 0 | C[I + 32 >> 2], B = 0 | C[I + 36 >> 2], C[A >> 2] = (p ^ u) & 0 - g ^ u, C[A + 4 >> 2] = (D ^ F) & 0 - g ^ F, C[A + 8 >> 2] = (s ^ h) & 0 - g ^ h, C[A + 12 >> 2] = (w ^ y) & 0 - g ^ y, C[A + 16 >> 2] = (t ^ f) & 0 - g ^ f, C[A + 20 >> 2] = (n ^ r) & 0 - g ^ r, C[A + 24 >> 2] = (c ^ a) & 0 - g ^ a, C[A + 28 >> 2] = (e ^ o) & 0 - g ^ o, C[A + 32 >> 2] = (E ^ i) & 0 - g ^ i, C[A + 36 >> 2] = (B ^ Q) & 0 - g ^ Q, C[I >> 2] = (p ^ u) & 0 - g ^ p, C[I + 4 >> 2] = (D ^ F) & 0 - g ^ D, C[I + 8 >> 2] = (s ^ h) & 0 - g ^ s, C[I + 12 >> 2] = (w ^ y) & 0 - g ^ w, C[I + 16 >> 2] = (t ^ f) & 0 - g ^ t, C[I + 20 >> 2] = (n ^ r) & 0 - g ^ n, C[I + 24 >> 2] = (c ^ a) & 0 - g ^ c, C[I + 28 >> 2] = (e ^ o) & 0 - g ^ e, C[I + 32 >> 2] = (E ^ i) & 0 - g ^ E, C[I + 36 >> 2] = (B ^ Q) & 0 - g ^ B;
          }

          function IA(A, I, g, E, i) {
            A |= 0, E |= 0, i |= 0;
            var e,
                c,
                a = 0,
                n = 0,
                r = 0,
                t = 0,
                f = 0;

            if (e = y, c = y = y + 63 & -64, y = y + 112 | 0, !(0 == (0 | (I |= 0)) & 0 == (0 | (g |= 0)))) {
              a = (n = c) + 32 | 0;

              do {
                B[n >> 0] = 0 | B[i >> 0], n = n + 1 | 0, i = i + 1 | 0;
              } while ((0 | n) < (0 | a));

              if (n = Q[E + 4 >> 0] | Q[E + 4 + 1 >> 0] << 8 | Q[E + 4 + 2 >> 0] << 16 | Q[E + 4 + 3 >> 0] << 24, C[c + 96 >> 2] = Q[E >> 0] | Q[E + 1 >> 0] << 8 | Q[E + 2 >> 0] << 16 | Q[E + 3 >> 0] << 24, C[c + 96 + 4 >> 2] = n, C[c + 96 + 8 >> 2] = 0, C[c + 96 + 8 + 4 >> 2] = 0, g >>> 0 > 0 | 0 == (0 | g) & I >>> 0 > 63) {
                do {
                  for (iB(A, c + 96 | 0, c), a = 8, i = 1; i = i + (0 | Q[(n = c + 96 + a | 0) >> 0]) | 0, B[n >> 0] = i, 16 != (0 | (a = a + 1 | 0));) {
                    i >>>= 8;
                  }

                  I = 0 | vg(0 | I, 0 | g, -64, -1), g = 0 | o(), A = A + 64 | 0;
                } while (g >>> 0 > 0 | 0 == (0 | g) & I >>> 0 > 63);

                0 == (0 | I) & 0 == (0 | g) || (t = A, f = I, r = 8);
              } else t = A, f = I, r = 8;

              if (8 == (0 | r) && (iB(c + 32 | 0, c + 96 | 0, c), 0 | f)) {
                i = 0;

                do {
                  B[t + i >> 0] = 0 | B[c + 32 + i >> 0], i = i + 1 | 0;
                } while ((0 | i) != (0 | f));
              }

              MI(c + 32 | 0, 64), MI(c, 32);
            }

            y = e;
          }

          function gA(A, I, g, B, C, Q, E) {
            A |= 0, I |= 0, g |= 0, B |= 0, C |= 0;
            var i,
                e,
                c = 0;
            return e = y, i = y = y + 63 & -64, y = y + 96 | 0, x(i, Q |= 0, E |= 0), function (A, I, g) {
              IA(A |= 0, 32, 0, I |= 0, g |= 0);
            }(i + 32 | 0, Q + 16 | 0, i), 0 | function (A, I, g, B, C) {
              return 0 | function (A, I, g, B, C) {
                var Q, E;
                return A |= 0, Q = y, E = y = y + 63 & -64, y = y + 16 | 0, function (A, I, g, B, C) {
                  var Q, E;
                  A |= 0, I |= 0, g |= 0, B |= 0, Q = y, E = y = y + 63 & -64, y = y + 96 | 0, MA(E, C |= 0), K(E, I, g, B), z(E, A), y = Q;
                }(E, I |= 0, g |= 0, B |= 0, C |= 0), C = 0 | tB(A, E), y = Q, 0 | C;
              }(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0);
            }(g, I, B, C, i + 32 | 0) ? (MI(i, 32), I = -1) : A ? (I >>> 0 >= A >>> 0 && 0 < C >>> 0 | 0 == (0 | C) & (I - A | 0) >>> 0 < B >>> 0 ? c = 8 : A >>> 0 >= I >>> 0 && 0 < C >>> 0 | 0 == (0 | C) & (A - I | 0) >>> 0 < B >>> 0 ? c = 8 : g = I, 8 == (0 | c) && (YI(0 | A, 0 | I, 0 | B), g = A), 0 == (0 | (I = C >>> 0 > 0 | 0 == (0 | C) & B >>> 0 > 32 ? 32 : B)) & 0 == (0 | (E = C >>> 0 > 0 | 0 == (0 | C) & B >>> 0 > 32 ? 0 : C)) ? Yg(i + 32 | 0, i + 32 | 0, 32, 0, Q + 16 | 0, i) : (BA(i + 32 + 32 | 0, 0 | g, -2 - (c = ~C >>> 0 > 4294967295 | -1 == (0 | ~C) & ~B >>> 0 > 4294967263 ? ~B : -33) + 1 | 0), Yg(i + 32 | 0, i + 32 | 0, 0 | vg(0 | I, 0 | E, 32, 0), 0 | o(), Q + 16 | 0, i), BA(0 | A, i + 32 + 32 | 0, -2 - c + 1 | 0)), C >>> 0 > 0 | 0 == (0 | C) & B >>> 0 > 32 && _g(A + I | 0, g + I | 0, 0 | Ug(0 | B, 0 | C, 0 | I, 0 | E), 0 | o(), Q + 16 | 0, i), MI(i, 32), I = 0) : I = 0, y = e, 0 | I;
          }

          function BA(A, I, g) {
            A |= 0, I |= 0;
            var Q,
                E,
                i = 0;
            if ((0 | (g |= 0)) >= 8192) return t(0 | A, 0 | I, 0 | g), 0 | A;

            if (E = 0 | A, Q = A + g | 0, (3 & A) == (3 & I)) {
              for (; 3 & A;) {
                if (!g) return 0 | E;
                B[A >> 0] = 0 | B[I >> 0], A = A + 1 | 0, I = I + 1 | 0, g = g - 1 | 0;
              }

              for (i = (g = -4 & Q | 0) - 64 | 0; (0 | A) <= (0 | i);) {
                C[A >> 2] = C[I >> 2], C[A + 4 >> 2] = C[I + 4 >> 2], C[A + 8 >> 2] = C[I + 8 >> 2], C[A + 12 >> 2] = C[I + 12 >> 2], C[A + 16 >> 2] = C[I + 16 >> 2], C[A + 20 >> 2] = C[I + 20 >> 2], C[A + 24 >> 2] = C[I + 24 >> 2], C[A + 28 >> 2] = C[I + 28 >> 2], C[A + 32 >> 2] = C[I + 32 >> 2], C[A + 36 >> 2] = C[I + 36 >> 2], C[A + 40 >> 2] = C[I + 40 >> 2], C[A + 44 >> 2] = C[I + 44 >> 2], C[A + 48 >> 2] = C[I + 48 >> 2], C[A + 52 >> 2] = C[I + 52 >> 2], C[A + 56 >> 2] = C[I + 56 >> 2], C[A + 60 >> 2] = C[I + 60 >> 2], A = A + 64 | 0, I = I + 64 | 0;
              }

              for (; (0 | A) < (0 | g);) {
                C[A >> 2] = C[I >> 2], A = A + 4 | 0, I = I + 4 | 0;
              }
            } else for (g = Q - 4 | 0; (0 | A) < (0 | g);) {
              B[A >> 0] = 0 | B[I >> 0], B[A + 1 >> 0] = 0 | B[I + 1 >> 0], B[A + 2 >> 0] = 0 | B[I + 2 >> 0], B[A + 3 >> 0] = 0 | B[I + 3 >> 0], A = A + 4 | 0, I = I + 4 | 0;
            }

            for (; (0 | A) < (0 | Q);) {
              B[A >> 0] = 0 | B[I >> 0], A = A + 1 | 0, I = I + 1 | 0;
            }

            return 0 | E;
          }

          function CA(A, I) {
            A |= 0;
            var g,
                Q,
                E = 0;
            g = y, Q = y = y + 63 & -64, y = y + 48 | 0, function (A, I) {
              var g, B, Q, E, i, e, o, c, a, n, r;
              A |= 0, a = 0 | C[(I |= 0) >> 2], r = 0 | C[I + 4 >> 2], o = 0 | C[I + 8 >> 2], e = 0 | C[I + 12 >> 2], i = 0 | C[I + 16 >> 2], n = 0 | C[I + 20 >> 2], Q = 0 | C[I + 24 >> 2], B = 0 | C[I + 28 >> 2], g = 0 | C[I + 32 >> 2], E = (((((c = ((19 * ((((((((((((16777216 + (19 * (I = 0 | C[I + 36 >> 2]) | 0) | 0) >>> 25) + a >> 26) + r >> 25) + o >> 26) + e >> 25) + i >> 26) + n >> 25) + Q >> 26) + B >> 25) + g >> 26) + I >> 25) | 0) + a >> 26) + r | 0) >> 25) + o >> 26) + e >> 25) + i >> 26) + n | 0, C[A >> 2] = (19 * ((((((((((((16777216 + (19 * I | 0) | 0) >>> 25) + a >> 26) + r >> 25) + o >> 26) + e >> 25) + i >> 26) + n >> 25) + Q >> 26) + B >> 25) + g >> 26) + I >> 25) | 0) + a & 67108863, C[A + 4 >> 2] = 33554431 & c, C[A + 8 >> 2] = (c >> 25) + o & 67108863, C[A + 12 >> 2] = ((c >> 25) + o >> 26) + e & 33554431, C[A + 16 >> 2] = (((c >> 25) + o >> 26) + e >> 25) + i & 67108863, C[A + 20 >> 2] = 33554431 & E, C[A + 24 >> 2] = (E >> 25) + Q & 67108863, C[A + 28 >> 2] = ((E >> 25) + Q >> 26) + B & 33554431, C[A + 32 >> 2] = (((E >> 25) + Q >> 26) + B >> 25) + g & 67108863, C[A + 36 >> 2] = ((((E >> 25) + Q >> 26) + B >> 25) + g >> 26) + I & 33554431;
            }(Q, I |= 0), I = 0 | C[Q >> 2], B[A >> 0] = I, B[A + 1 >> 0] = I >>> 8, B[A + 2 >> 0] = I >>> 16, E = 0 | C[Q + 4 >> 2], B[A + 3 >> 0] = E << 2 | I >>> 24, B[A + 4 >> 0] = E >>> 6, B[A + 5 >> 0] = E >>> 14, I = 0 | C[Q + 8 >> 2], B[A + 6 >> 0] = I << 3 | E >>> 22, B[A + 7 >> 0] = I >>> 5, B[A + 8 >> 0] = I >>> 13, E = 0 | C[Q + 12 >> 2], B[A + 9 >> 0] = E << 5 | I >>> 21, B[A + 10 >> 0] = E >>> 3, B[A + 11 >> 0] = E >>> 11, I = 0 | C[Q + 16 >> 2], B[A + 12 >> 0] = I << 6 | E >>> 19, B[A + 13 >> 0] = I >>> 2, B[A + 14 >> 0] = I >>> 10, B[A + 15 >> 0] = I >>> 18, I = 0 | C[Q + 20 >> 2], B[A + 16 >> 0] = I, B[A + 17 >> 0] = I >>> 8, B[A + 18 >> 0] = I >>> 16, E = 0 | C[Q + 24 >> 2], B[A + 19 >> 0] = E << 1 | I >>> 24, B[A + 20 >> 0] = E >>> 7, B[A + 21 >> 0] = E >>> 15, I = 0 | C[Q + 28 >> 2], B[A + 22 >> 0] = I << 3 | E >>> 23, B[A + 23 >> 0] = I >>> 5, B[A + 24 >> 0] = I >>> 13, E = 0 | C[Q + 32 >> 2], B[A + 25 >> 0] = E << 4 | I >>> 21, B[A + 26 >> 0] = E >>> 4, B[A + 27 >> 0] = E >>> 12, I = 0 | C[Q + 36 >> 2], B[A + 28 >> 0] = I << 6 | E >>> 20, B[A + 29 >> 0] = I >>> 2, B[A + 30 >> 0] = I >>> 10, B[A + 31 >> 0] = I >>> 18, y = g;
          }

          function QA(A, I, g) {
            A |= 0, I |= 0, g |= 0;
            var B,
                E,
                i = 0,
                e = 0,
                c = 0;

            if (B = y, E = y = y + 63 & -64, y = y + 4096 | 0, yB(E + 3072 | 0), yB(E + 2048 | 0), 0 != (0 | A) & 0 != (0 | I) && (C[E + 2048 >> 2] = C[I >> 2], C[E + 2048 + 4 >> 2] = 0, C[E + 2048 + 8 >> 2] = C[I + 4 >> 2], C[E + 2048 + 8 + 4 >> 2] = 0, C[E + 2048 + 16 >> 2] = Q[I + 8 >> 0], C[E + 2048 + 16 + 4 >> 2] = 0, C[E + 2048 + 24 >> 2] = C[A + 16 >> 2], C[E + 2048 + 24 + 4 >> 2] = 0, C[E + 2048 + 32 >> 2] = C[A + 8 >> 2], C[E + 2048 + 32 + 4 >> 2] = 0, C[E + 2048 + 40 >> 2] = C[A + 36 >> 2], C[E + 2048 + 40 + 4 >> 2] = 0, 0 | C[A + 20 >> 2])) {
              I = 0;

              do {
                (i = 127 & I) || (c = 0 | vg(0 | C[E + 2048 + 48 >> 2], 0 | C[E + 2048 + 48 + 4 >> 2], 1, 0), e = 0 | o(), C[E + 2048 + 48 >> 2] = c, C[E + 2048 + 48 + 4 >> 2] = e, yB(E), yB(E + 1024 | 0), H(E + 3072 | 0, E + 2048 | 0, E), H(E + 3072 | 0, E, E + 1024 | 0)), e = 0 | C[E + 1024 + (i << 3) + 4 >> 2], C[(c = g + (I << 3) | 0) >> 2] = C[E + 1024 + (i << 3) >> 2], C[c + 4 >> 2] = e, I = I + 1 | 0;
              } while (I >>> 0 < (0 | C[A + 20 >> 2]) >>> 0);
            }

            y = B;
          }

          function EA(A, I, g, B) {
            A |= 0, I |= 0, g |= 0, B |= 0;
            var Q,
                E,
                i,
                e,
                o = 0,
                c = 0,
                a = 0;
            e = y, i = y = y + 63 & -64, y = y + 64 | 0, c = 52 + (o = i + 8 | 0) | 0;

            do {
              C[o >> 2] = 0, o = o + 4 | 0;
            } while ((0 | o) < (0 | c));

            o = 0 | ZA(A), C[i + 36 >> 2] = o, C[i + 20 >> 2] = o, C[i + 4 >> 2] = o, c = 0 | F(o), C[i + 32 >> 2] = c, Q = 0 | F(o), C[i + 16 >> 2] = Q, E = 0 | F(o), C[i >> 2] = E;

            do {
              if (0 == (0 | c) | 0 == (0 | Q) | 0 == (0 | E)) d(c), d(Q), d(E), o = -22;else {
                if (!(a = 0 | F(o))) {
                  d(c), d(Q), d(E), o = -22;
                  break;
                }

                if (0 | (o = 0 | L(i, A, B))) {
                  d(0 | C[i + 32 >> 2]), d(0 | C[i + 16 >> 2]), d(0 | C[i >> 2]), d(a);
                  break;
                }

                B = 0 | nA(0 | C[i + 40 >> 2], 0 | C[i + 44 >> 2], 0 | C[i + 52 >> 2], I, g, 0 | C[i + 16 >> 2], 0 | C[i + 20 >> 2], a, 0 | C[i + 4 >> 2], 0, 0, B), d(0 | C[i + 32 >> 2]), d(0 | C[i + 16 >> 2]), o = 0 == (0 | B) && 0 == (0 | EI(a, 0 | C[i >> 2], 0 | C[i + 4 >> 2])) ? 0 : -35, d(a), d(0 | C[i >> 2]);
              }
            } while (0);

            return y = e, 0 | o;
          }

          function iA(A, I) {
            A |= 0, I |= 0;
            var g,
                C,
                E = 0,
                i = 0,
                e = 0;
            g = y, C = y = y + 63 & -64, y = y + 464 | 0, E = 0;

            do {
              e = 0 | B[I + E >> 0], B[C + (i = E << 1) >> 0] = 15 & e, B[C + (1 | i) >> 0] = (255 & e) >>> 4, E = E + 1 | 0;
            } while (32 != (0 | E));

            I = 0, E = 0;

            do {
              I = 134217728 + ((i = I + (0 | Q[(e = C + E | 0) >> 0]) | 0) << 24) >> 28, B[e >> 0] = i - (I << 4), E = E + 1 | 0;
            } while (63 != (0 | E));

            B[C + 63 >> 0] = I + (0 | Q[C + 63 >> 0]), Og(A), I = 1;

            do {
              $g(C + 64 | 0, I >>> 1, 0 | B[C + I >> 0]), CI(C + 304 | 0, A, C + 64 | 0), Eg(A, C + 304 | 0), I = I + 2 | 0;
            } while (I >>> 0 < 64);

            og(C + 304 | 0, A), Hg(C + 184 | 0, C + 304 | 0), aI(C + 304 | 0, C + 184 | 0), Hg(C + 184 | 0, C + 304 | 0), aI(C + 304 | 0, C + 184 | 0), Hg(C + 184 | 0, C + 304 | 0), aI(C + 304 | 0, C + 184 | 0), Eg(A, C + 304 | 0), I = 0;

            do {
              $g(C + 64 | 0, I >>> 1, 0 | B[C + I >> 0]), CI(C + 304 | 0, A, C + 64 | 0), Eg(A, C + 304 | 0), I = I + 2 | 0;
            } while (I >>> 0 < 64);

            y = g;
          }

          function eA(A, I, g, B, C, Q, E, i, e, c, a) {
            var n;
            A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, n = y, y = y + 352 | 0, OI(n + 16 | 0, 64, 0, c |= 0, a |= 0), gB(n + 80 | 0, n + 16 | 0), MI(n + 16 | 0, 64), bg(n + 80 | 0, E, i, e), I = 0 | Ug(0, 0, 0 | i, 0 | e), o(), bg(n + 80 | 0, 34624, 15 & I, 0), bg(n + 80 | 0, g, B, C), I = 0 | Ug(0, 0, 0 | B, 0 | C), o(), bg(n + 80 | 0, 34624, 15 & I, 0), LI(n + 336 | 0, i, e), bg(n + 80 | 0, n + 336 | 0, 8, 0), LI(n + 336 | 0, B, C), bg(n + 80 | 0, n + 336 | 0, 8, 0), IB(n + 80 | 0, n), MI(n + 80 | 0, 256), I = 0 | tB(n, Q), MI(n, 16);

            do {
              if (A) {
                if (I) {
                  YA(0 | A, 0, 0 | B), I = -1;
                  break;
                }

                rI(A, g, B, C, c, 1, a), I = 0;
                break;
              }
            } while (0);

            return y = n, 0 | I;
          }

          function oA(A) {
            A |= 0;
            var I = 0,
                g = 0;

            do {
              if (A) {
                if (0 | C[A >> 2]) {
                  if ((0 | C[A + 4 >> 2]) >>> 0 >= 16) {
                    if (0 == (0 | C[A + 8 >> 2]) && 0 | C[A + 12 >> 2]) {
                      I = -18;
                      break;
                    }

                    if (I = 0 | C[A + 20 >> 2], !(0 | C[A + 16 >> 2])) return 0 | (0 == (0 | I) ? -6 : -19);

                    if (I >>> 0 >= 8) {
                      if (0 == (0 | C[A + 24 >> 2]) && 0 | C[A + 28 >> 2]) {
                        I = -20;
                        break;
                      }

                      if (0 == (0 | C[A + 32 >> 2]) && 0 | C[A + 36 >> 2]) {
                        I = -21;
                        break;
                      }

                      if ((I = 0 | C[A + 44 >> 2]) >>> 0 >= 8) {
                        if (I >>> 0 <= 2097152) {
                          if (I >>> 0 >= (g = 0 | C[A + 48 >> 2]) << 3 >>> 0) {
                            if (0 | C[A + 40 >> 2]) {
                              if (g) {
                                if (!(g >>> 0 > 16777215)) return 0 | (0 == (0 | (A = 0 | C[A + 52 >> 2])) ? -28 : A >>> 0 > 16777215 ? -29 : 0);
                                I = -17;
                              } else I = -16;
                            } else I = -12;
                          } else I = -14;
                        } else I = -15;
                      } else I = -14;
                    } else I = -6;
                  } else I = -2;
                } else I = -1;
              } else I = -25;
            } while (0);

            return 0 | I;
          }

          function cA(A, I, g, Q, E) {
            var i, e;
            A |= 0, g |= 0, Q |= 0, E |= 0, i = y, e = y = y + 63 & -64, y = y + 192 | 0, ((I |= 0) - 1 & 255) > 63 && SB(), g || SB(), B[e + 128 >> 0] = I, B[e + 128 + 1 >> 0] = 32, B[e + 128 + 2 >> 0] = 1, B[e + 128 + 3 >> 0] = 1, Wg(e + 128 + 4 | 0), LI(e + 128 + 8 | 0, 0, 0), C[e + 128 + 16 >> 2] = 0, C[e + 128 + 16 + 4 >> 2] = 0, C[e + 128 + 16 + 8 >> 2] = 0, C[e + 128 + 16 + 12 >> 2] = 0, Q ? function (A, I) {
              I |= 0;
              var g = 0;
              A = 16 + (g = 32 + (A |= 0) | 0) | 0;

              do {
                B[g >> 0] = 0 | B[I >> 0], g = g + 1 | 0, I = I + 1 | 0;
              } while ((0 | g) < (0 | A));
            }(e + 128 | 0, Q) : (C[e + 128 + 32 >> 2] = 0, C[e + 128 + 32 + 4 >> 2] = 0, C[e + 128 + 32 + 8 >> 2] = 0, C[e + 128 + 32 + 12 >> 2] = 0), E ? function (A, I) {
              I |= 0;
              var g = 0;
              A = 16 + (g = 48 + (A |= 0) | 0) | 0;

              do {
                B[g >> 0] = 0 | B[I >> 0], g = g + 1 | 0, I = I + 1 | 0;
              } while ((0 | g) < (0 | A));
            }(e + 128 | 0, E) : (C[e + 128 + 48 >> 2] = 0, C[e + 128 + 48 + 4 >> 2] = 0, C[e + 128 + 48 + 8 >> 2] = 0, C[e + 128 + 48 + 12 >> 2] = 0), XA(A, e + 128 | 0), E = 96 + (I = e + 32 | 0) | 0;

            do {
              C[I >> 2] = 0, I = I + 4 | 0;
            } while ((0 | I) < (0 | E));

            E = (I = e) + 32 | 0;

            do {
              B[I >> 0] = 0 | B[g >> 0], I = I + 1 | 0, g = g + 1 | 0;
            } while ((0 | I) < (0 | E));

            $(A, e, 128, 0), MI(e, 128), y = i;
          }

          function aA(A, I, g) {
            var C, E;
            I |= 0, g |= 0, C = 0 | vg(Q[64 + (A |= 0) >> 0] | Q[A + 64 + 1 >> 0] << 8 | Q[A + 64 + 2 >> 0] << 16 | Q[A + 64 + 3 >> 0] << 24 | 0, Q[A + 64 + 4 >> 0] | Q[A + 64 + 4 + 1 >> 0] << 8 | Q[A + 64 + 4 + 2 >> 0] << 16 | Q[A + 64 + 4 + 3 >> 0] << 24 | 0, 0 | I, 0 | g), E = 0 | o(), B[A + 64 >> 0] = C, B[A + 64 + 1 >> 0] = C >> 8, B[A + 64 + 2 >> 0] = C >> 16, B[A + 64 + 3 >> 0] = C >> 24, B[A + 64 + 4 >> 0] = E, B[A + 64 + 4 + 1 >> 0] = E >> 8, B[A + 64 + 4 + 2 >> 0] = E >> 16, B[A + 64 + 4 + 3 >> 0] = E >> 24, I = 0 | vg(Q[A + 72 >> 0] | Q[A + 72 + 1 >> 0] << 8 | Q[A + 72 + 2 >> 0] << 16 | Q[A + 72 + 3 >> 0] << 24 | 0, Q[A + 72 + 4 >> 0] | Q[A + 72 + 4 + 1 >> 0] << 8 | Q[A + 72 + 4 + 2 >> 0] << 16 | Q[A + 72 + 4 + 3 >> 0] << 24 | 0, 1 & (E >>> 0 < g >>> 0 | (0 | E) == (0 | g) & C >>> 0 < I >>> 0) | 0, 0), g = 0 | o(), B[A + 72 >> 0] = I, B[A + 72 + 1 >> 0] = I >> 8, B[A + 72 + 2 >> 0] = I >> 16, B[A + 72 + 3 >> 0] = I >> 24, B[A + 72 + 4 >> 0] = g, B[A + 72 + 4 + 1 >> 0] = g >> 8, B[A + 72 + 4 + 2 >> 0] = g >> 16, B[A + 72 + 4 + 3 >> 0] = g >> 24;
          }

          function nA(A, I, g, B, Q, E, i, e, o, c, a, n) {
            var r, t, f;
            A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, f = y, t = y = y + 63 & -64, y = y + 64 | 0, r = 0 | F(o |= 0);

            do {
              if (r) {
                if (C[t >> 2] = r, C[t + 4 >> 2] = o, C[t + 8 >> 2] = B, C[t + 12 >> 2] = Q, C[t + 16 >> 2] = E, C[t + 20 >> 2] = i, C[t + 24 >> 2] = 0, C[t + 24 + 4 >> 2] = 0, C[t + 24 + 8 >> 2] = 0, C[t + 24 + 12 >> 2] = 0, C[t + 40 >> 2] = A, C[t + 44 >> 2] = I, C[t + 48 >> 2] = g, C[t + 52 >> 2] = g, C[t + 56 >> 2] = 0, 0 | (I = 0 | pA(t, n))) {
                  MI(r, o), d(r);
                  break;
                }

                if (0 | e && BA(0 | e, 0 | r, 0 | o), 0 != (0 | c) & 0 != (0 | a) && 0 | J(c, a, t, n)) {
                  MI(r, o), MI(c, a), d(r), I = -31;
                  break;
                }

                MI(r, o), d(r), I = 0;
              } else I = -22;
            } while (0);

            return y = f, 0 | I;
          }

          function rA(A, I) {
            var g,
                B,
                C = 0;
            return B = y, g = y = y + 63 & -64, y = y + 288 | 0, U(40 + (A |= 0) | 0, I |= 0), Sg(A + 80 | 0), _(g + 240 | 0, A + 40 | 0), u(g + 192 | 0, g + 240 | 0, 16), lA(g + 240 | 0, g + 240 | 0, A + 80 | 0), _A(g + 192 | 0, g + 192 | 0, A + 80 | 0), _(g + 144 | 0, g + 192 | 0), u(g + 144 | 0, g + 144 | 0, g + 192 | 0), _(A, g + 144 | 0), u(A, A, g + 192 | 0), u(A, A, g + 240 | 0), function (A, I) {
              A |= 0;
              var g,
                  B,
                  C = 0;
              g = y, B = y = y + 63 & -64, y = y + 144 | 0, _(B + 96 | 0, I |= 0), _(B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 48 | 0), u(B + 48 | 0, I, B + 48 | 0), u(B + 96 | 0, B + 96 | 0, B + 48 | 0), _(B + 96 | 0, B + 96 | 0), u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 96 | 0), C = 1;

              do {
                _(B + 48 | 0, B + 48 | 0), C = C + 1 | 0;
              } while (5 != (0 | C));

              u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 96 | 0), C = 1;

              do {
                _(B + 48 | 0, B + 48 | 0), C = C + 1 | 0;
              } while (10 != (0 | C));

              u(B + 48 | 0, B + 48 | 0, B + 96 | 0), _(B, B + 48 | 0), C = 1;

              do {
                _(B, B), C = C + 1 | 0;
              } while (20 != (0 | C));

              u(B + 48 | 0, B, B + 48 | 0), _(B + 48 | 0, B + 48 | 0), C = 1;

              do {
                _(B + 48 | 0, B + 48 | 0), C = C + 1 | 0;
              } while (10 != (0 | C));

              u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 48 | 0, B + 96 | 0), C = 1;

              do {
                _(B + 48 | 0, B + 48 | 0), C = C + 1 | 0;
              } while (50 != (0 | C));

              u(B + 48 | 0, B + 48 | 0, B + 96 | 0), _(B, B + 48 | 0), C = 1;

              do {
                _(B, B), C = C + 1 | 0;
              } while (100 != (0 | C));

              u(B + 48 | 0, B, B + 48 | 0), _(B + 48 | 0, B + 48 | 0), C = 1;

              do {
                _(B + 48 | 0, B + 48 | 0), C = C + 1 | 0;
              } while (50 != (0 | C));

              u(B + 96 | 0, B + 48 | 0, B + 96 | 0), _(B + 96 | 0, B + 96 | 0), _(B + 96 | 0, B + 96 | 0), u(A, B + 96 | 0, I), y = g;
            }(A, A), u(A, A, g + 144 | 0), u(A, A, g + 240 | 0), _(g + 96 | 0, A), u(g + 96 | 0, g + 96 | 0, g + 192 | 0), lA(g + 48 | 0, g + 96 | 0, g + 240 | 0), 0 | cg(g + 48 | 0) ? C = 4 : (_A(g, g + 96 | 0, g + 240 | 0), 0 | cg(g) ? (u(A, A, 64), C = 4) : A = -1), 4 == (0 | C) && ((0 | (C = 0 | sg(A))) == ((0 | Q[I + 31 >> 0]) >>> 7 | 0) && xA(A, A), u(A + 120 | 0, A, A + 40 | 0), A = 0), y = B, 0 | A;
          }

          function tA(A, I, g) {
            var B, Q, E, i, e, o, c, a, n, r, t, f, w, y, s, h, D, F, p;
            I |= 0, g |= 0, p = 0 | C[(A |= 0) >> 2], D = 0 | C[A + 4 >> 2], s = 0 | C[A + 8 >> 2], w = 0 | C[A + 12 >> 2], t = 0 | C[A + 16 >> 2], n = 0 | C[A + 20 >> 2], c = 0 | C[A + 24 >> 2], e = 0 | C[A + 28 >> 2], E = 0 | C[A + 32 >> 2], B = 0 | C[A + 36 >> 2], F = (C[I + 4 >> 2] ^ D) & 0 - g, h = (C[I + 8 >> 2] ^ s) & 0 - g, y = (C[I + 12 >> 2] ^ w) & 0 - g, f = (C[I + 16 >> 2] ^ t) & 0 - g, r = (C[I + 20 >> 2] ^ n) & 0 - g, a = (C[I + 24 >> 2] ^ c) & 0 - g, o = (C[I + 28 >> 2] ^ e) & 0 - g, i = (C[I + 32 >> 2] ^ E) & 0 - g, Q = (C[I + 36 >> 2] ^ B) & 0 - g, C[A >> 2] = (C[I >> 2] ^ p) & 0 - g ^ p, C[A + 4 >> 2] = F ^ D, C[A + 8 >> 2] = h ^ s, C[A + 12 >> 2] = y ^ w, C[A + 16 >> 2] = f ^ t, C[A + 20 >> 2] = r ^ n, C[A + 24 >> 2] = a ^ c, C[A + 28 >> 2] = o ^ e, C[A + 32 >> 2] = i ^ E, C[A + 36 >> 2] = Q ^ B;
          }

          function fA(A, I, g, B, Q, E, i, e, c, a, n, r) {
            return A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, a = y, y = y + 336 | 0, OI(a, 64, 0, n |= 0, r |= 0), gB(a + 64 | 0, a), MI(a, 64), bg(a + 64 | 0, i, e, c), i = 0 | Ug(0, 0, 0 | e, 0 | c), o(), bg(a + 64 | 0, 34624, 15 & i, 0), rI(A, B, Q, E, n, 1, r), bg(a + 64 | 0, A, Q, E), n = 0 | Ug(0, 0, 0 | Q, 0 | E), o(), bg(a + 64 | 0, 34624, 15 & n, 0), LI(a + 320 | 0, e, c), bg(a + 64 | 0, a + 320 | 0, 8, 0), LI(a + 320 | 0, Q, E), bg(a + 64 | 0, a + 320 | 0, 8, 0), IB(a + 64 | 0, I), MI(a + 64 | 0, 256), 0 | g && (C[g >> 2] = 16, C[g + 4 >> 2] = 0), y = a, 0;
          }

          function wA(A) {
            var I,
                g,
                E = 0,
                i = 0,
                e = 0;
            I = y, g = y = y + 63 & -64, y = y + 48 | 0, i = A |= 0, e = (E = g) + 32 | 0;

            do {
              B[E >> 0] = 0 | B[i >> 0], E = E + 1 | 0, i = i + 1 | 0;
            } while ((0 | E) < (0 | e));

            E = Q[A + 36 + 4 >> 0] | Q[A + 36 + 4 + 1 >> 0] << 8 | Q[A + 36 + 4 + 2 >> 0] << 16 | Q[A + 36 + 4 + 3 >> 0] << 24, C[g + 32 >> 2] = Q[A + 36 >> 0] | Q[A + 36 + 1 >> 0] << 8 | Q[A + 36 + 2 >> 0] << 16 | Q[A + 36 + 3 >> 0] << 24, C[g + 32 + 4 >> 2] = E, function (A, I, g, B) {
              !function (A, I, g, B) {
                fI(A |= 0, I |= 0, 40, 0, g |= 0, 0, B |= 0);
              }(A |= 0, I |= 0, g |= 0, B |= 0);
            }(g, g, A + 32 | 0, A), i = g, e = (E = A) + 32 | 0;

            do {
              B[E >> 0] = 0 | B[i >> 0], E = E + 1 | 0, i = i + 1 | 0;
            } while ((0 | E) < (0 | e));

            i = 0 | C[g + 32 >> 2], e = 0 | C[g + 32 + 4 >> 2], B[A + 36 >> 0] = i, B[A + 36 + 1 >> 0] = i >> 8, B[A + 36 + 2 >> 0] = i >> 16, B[A + 36 + 3 >> 0] = i >> 24, B[A + 36 + 4 >> 0] = e, B[A + 36 + 4 + 1 >> 0] = e >> 8, B[A + 36 + 4 + 2 >> 0] = e >> 16, B[A + 36 + 4 + 3 >> 0] = e >> 24, Mg(A), y = I;
          }

          function yA(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                C = 0,
                E = 0,
                i = 0,
                e = 0;
            g = 0;

            do {
              B[A + g >> 0] = (0 | Q[I + (g >>> 3) >> 0]) >>> (7 & g) & 1, g = g + 1 | 0;
            } while (256 != (0 | g));

            e = 0;

            do {
              E = A + e | 0;

              A: do {
                if (0 | B[E >> 0]) {
                  i = 1;

                  do {
                    if ((g = i + e | 0) >>> 0 >= 256) break A;
                    I = 0 | B[A + g >> 0];

                    I: do {
                      if (I << 24 >> 24) {
                        if (((C = I << 24 >> 24 << i) + (I = 0 | B[E >> 0]) | 0) < 16) {
                          B[E >> 0] = C + I, B[A + g >> 0] = 0;
                          break;
                        }

                        if ((I - C | 0) < -15) break A;

                        for (B[E >> 0] = I - C; 0 | B[(I = A + g | 0) >> 0];) {
                          if (B[I >> 0] = 0, (g = g + 1 | 0) >>> 0 >= 256) break I;
                        }

                        B[I >> 0] = 1;
                      }
                    } while (0);

                    i = i + 1 | 0;
                  } while (i >>> 0 < 7);
                }
              } while (0);

              e = e + 1 | 0;
            } while (256 != (0 | e));
          }

          function sA(A, I, g, B, C, Q, E, i, e, o, c) {
            var a;
            A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, a = y, y = y + 352 | 0, QB(a + 16 | 0, o |= 0, c |= 0), gB(a + 80 | 0, a + 16 | 0), MI(a + 16 | 0, 64), bg(a + 80 | 0, E, i, e), LI(a + 336 | 0, i, e), bg(a + 80 | 0, a + 336 | 0, 8, 0), bg(a + 80 | 0, g, B, C), LI(a + 336 | 0, B, C), bg(a + 80 | 0, a + 336 | 0, 8, 0), IB(a + 80 | 0, a), MI(a + 80 | 0, 256), I = 0 | tB(a, Q), MI(a, 16);

            do {
              if (A) {
                if (I) {
                  YA(0 | A, 0, 0 | B), I = -1;
                  break;
                }

                zI(A, g, B, C, o, c), I = 0;
                break;
              }
            } while (0);

            return y = a, 0 | I;
          }

          function hA(A, I, g, B, Q, E, i) {
            var e, o;
            A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, e = y, o = y = y + 63 & -64, y = y + 560 | 0, Jg(o + 192 | 0, i |= 0), RI(o + 128 | 0, E, 32, 0), P(o + 192 | 0, o + 128 + 32 | 0, 32, 0), P(o + 192 | 0, g, B, Q), VI(o + 192 | 0, o + 64 | 0), YI(A + 32 | 0, E + 32 | 0, 32), p(o + 64 | 0), iA(o + 400 | 0, o + 64 | 0), sI(A, o + 400 | 0), Jg(o + 192 | 0, i), P(o + 192 | 0, A, 64, 0), P(o + 192 | 0, g, B, Q), VI(o + 192 | 0, o), p(o), Tg(o + 128 | 0), h(A + 32 | 0, o, o + 128 | 0, o + 64 | 0), MI(o + 128 | 0, 64), MI(o + 64 | 0, 64), 0 | I && (C[I >> 2] = 64, C[I + 4 >> 2] = 0), y = e;
          }

          function DA(A, I, g, B, Q, i) {
            A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, i |= 0;
            var e = 0;

            do {
              if (I) {
                if (e = (0 | C[A + 24 >> 2]) - (0 | C[A + 20 >> 2]) | 0, i) {
                  e = B + -1 + e | 0;
                  break;
                }

                e = e + ((0 == (0 | B)) << 31 >> 31) | 0;
                break;
              }

              if (!(g << 24 >> 24)) {
                e = B + -1 | 0;
                break;
              }

              if (e = 0 | E(0 | C[A + 20 >> 2], 255 & g), i) {
                e = B + -1 + e | 0;
                break;
              }

              e = e + ((0 == (0 | B)) << 31 >> 31) | 0;
              break;
            } while (0);

            return Qg(0 | Q, 0, 0 | Q, 0), Qg(0 | o(), 0, 0 | e, 0), i = 0 | Ug(e + -1 | 0, 0, 0 | o(), 0), Q = 0 | o(), 0 == (0 | I) | g << 24 >> 24 == 3 ? (e = 0, B = 0) : (e = 0 | E(0 | C[A + 20 >> 2], 1 + (255 & g) | 0), B = 0), A = 0 | Ag(0 | (I = 0 | vg(0 | i, 0 | Q, 0 | e, 0 | B)), 0 | (g = 0 | o()), 0 | C[A + 24 >> 2], 0), o(), 0 | A;
          }

          function FA(A, I, g, B, Q) {
            B |= 0, Q |= 0;
            var E,
                i,
                e,
                o = 0;
            if (e = y, i = y = y + 63 & -64, y = y + 64 | 0, (g |= 0) >>> 0 > 0 | 0 == (0 | g) & (I |= 0) >>> 0 > 4294967295 | (E = 0 | ZA(A |= 0)) >>> 0 > 127) C[8678] = 28, g = -1;else {
              o = (g = i) + 60 | 0;

              do {
                C[g >> 2] = 0, g = g + 4 | 0;
              } while ((0 | g) < (0 | o));

              (o = 0 | function (A) {
                var I;
                return (I = 0 | F(A |= 0)) && 3 & C[I + -4 >> 2] ? (YA(0 | I, 0, 0 | A), 0 | I) : 0 | I;
              }(E)) ? (C[i + 16 >> 2] = o, C[i + 8 >> 2] = o, C[i >> 2] = o, C[i + 20 >> 2] = E, C[i + 12 >> 2] = E, C[i + 4 >> 2] = E, C[i + 24 >> 2] = 0, C[i + 24 + 4 >> 2] = 0, C[i + 24 + 8 >> 2] = 0, C[i + 24 + 12 >> 2] = 0, 0 | L(i, A, Q) ? (C[8678] = 28, g = -1) : g = (0 | C[i + 40 >> 2]) == (0 | I) ? (0 | C[i + 44 >> 2]) != (B >>> 10 | 0) & 1 : 1, d(o)) : g = -1;
            }
            return y = e, 0 | g;
          }

          function pA(A, I) {
            I |= 0;
            var g,
                B,
                Q = 0,
                i = 0,
                e = 0;
            if (B = y, g = y = y + 63 & -64, y = y + 48 | 0, !(Q = 0 | oA(A |= 0))) if ((I + -1 | 0) >>> 0 <= 1) {
              if (i = 0 | C[A + 44 >> 2], Q = 0 | C[A + 48 >> 2], e = 0 | E(i = ((i >>> 0 < Q << 3 >>> 0 ? Q << 3 : i) >>> 0) / (Q << 2 >>> 0) | 0, Q << 2), C[g >> 2] = 0, C[g + 8 >> 2] = C[A + 40 >> 2], C[g + 12 >> 2] = -1, C[g + 16 >> 2] = e, C[g + 20 >> 2] = i, C[g + 24 >> 2] = i << 2, C[g + 28 >> 2] = Q, C[g + 32 >> 2] = C[A + 52 >> 2], C[g + 36 >> 2] = I, !(Q = 0 | function (A, I) {
                A |= 0, I |= 0;
                var g,
                    B,
                    Q = 0;
                B = y, g = y = y + 63 & -64, y = y + 80 | 0;

                do {
                  if (0 == (0 | A) | 0 == (0 | I)) Q = -25;else {
                    if (Q = 0 | F(C[A + 20 >> 2] << 3), C[A + 4 >> 2] = Q, Q) {
                      if (Q = 0 | bA(A, 0 | C[A + 16 >> 2])) {
                        ug(A, 0 | C[I + 56 >> 2]);
                        break;
                      }

                      j(g, I, 0 | C[A + 36 >> 2]), MI(g + 64 | 0, 8), KA(g, A), MI(g, 72), Q = 0;
                      break;
                    }

                    Q = -22;
                  }
                } while (0);

                return y = B, 0 | Q;
              }(g, A))) {
                if (0 | C[g + 8 >> 2]) {
                  Q = 0;

                  do {
                    UA(g, Q), Q = Q + 1 | 0;
                  } while (Q >>> 0 < (0 | C[g + 8 >> 2]) >>> 0);
                }

                !function (A, I) {
                  var g,
                      B,
                      Q = 0,
                      i = 0;

                  if (g = y, B = y = y + 63 & -64, y = y + 2048 | 0, 0 != (0 | (A |= 0)) & 0 != (0 | (I |= 0))) {
                    if (fB(B + 1024 | 0, (0 | C[4 + (0 | C[I >> 2]) >> 2]) + (C[I + 24 >> 2] << 10) - 1024 | 0), (0 | C[I + 28 >> 2]) >>> 0 > 1) {
                      Q = 1;

                      do {
                        i = (i = 0 | C[I + 24 >> 2]) - 1 + (0 | E(i, Q)) | 0, SI(B + 1024 | 0, (0 | C[4 + (0 | C[I >> 2]) >> 2]) + (i << 10) | 0), Q = Q + 1 | 0;
                      } while (Q >>> 0 < (0 | C[I + 28 >> 2]) >>> 0);
                    }

                    !function (A, I) {
                      A |= 0, I |= 0;
                      var g = 0,
                          B = 0;
                      g = 0;

                      do {
                        LI(A + (g << 3) | 0, 0 | C[(B = I + (g << 3) | 0) >> 2], 0 | C[B + 4 >> 2]), g = g + 1 | 0;
                      } while (128 != (0 | g));
                    }(B, B + 1024 | 0), T(0 | C[A >> 2], 0 | C[A + 4 >> 2], B, 1024), MI(B + 1024 | 0, 1024), MI(B, 1024), ug(I, 0 | C[A + 56 >> 2]);
                  }

                  y = g;
                }(A, g), Q = 0;
              }
            } else Q = -26;
            return y = B, 0 | Q;
          }

          function uA(A, I, g, B, C, Q) {
            var E, i;
            return I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, i = y, E = y = y + 63 & -64, y = y + 592 | 0, 0 != (0 | pI(32 + (A |= 0) | 0)) && 0 == (0 | GA(A)) && 0 != (0 | WI(C)) && 0 == (0 | GA(C)) && 0 == (0 | rA(E + 424 | 0, C)) ? (Jg(E + 96 | 0, Q), P(E + 96 | 0, A, 32, 0), P(E + 96 | 0, C, 32, 0), P(E + 96 | 0, I, g, B), VI(E + 96 | 0, E + 32 | 0), p(E + 32 | 0), N(E + 304 | 0, E + 32 | 0, E + 424 | 0, A + 32 | 0), sI(E, E + 304 | 0), g = 0 | rB(E, A), g = 0 | ((0 | E) == (0 | A) ? -1 : g) | EI(A, E, 32)) : g = -1, y = i, 0 | g;
          }

          function HA(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                Q = 0;

            A: do {
              if (255 & I) {
                if (3 & A) do {
                  if ((Q = 0 | B[A >> 0]) << 24 >> 24 == 0 || Q << 24 >> 24 == (255 & I) << 24 >> 24) break A;
                  A = A + 1 | 0;
                } while (0 != (3 & A | 0));
                Q = 0 | E(255 & I, 16843009), g = 0 | C[A >> 2];

                I: do {
                  if (!((-2139062144 & g ^ -2139062144) & g + -16843009)) do {
                    if ((-2139062144 & (g ^= Q) ^ -2139062144) & g + -16843009 | 0) break I;
                    g = 0 | C[(A = A + 4 | 0) >> 2];
                  } while (!((-2139062144 & g ^ -2139062144) & g + -16843009 | 0));
                } while (0);

                for (; (Q = 0 | B[A >> 0]) << 24 >> 24 != 0 && Q << 24 >> 24 != (255 & I) << 24 >> 24;) {
                  A = A + 1 | 0;
                }
              } else A = A + (0 | ZA(A)) | 0;
            } while (0);

            return 0 | A;
          }

          function kA(A, I) {
            I |= 0;
            var g,
                Q = 0,
                E = 0;
            g = y, y = y + 192 | 0, PI(A |= 0), E = 128 + (Q = g + 64 | 0) | 0;

            do {
              C[Q >> 2] = 909522486, Q = Q + 4 | 0;
            } while ((0 | Q) < (0 | E));

            B[g + 64 >> 0] = 54 ^ B[I >> 0], Q = 1;

            do {
              B[(E = g + 64 + Q | 0) >> 0] = B[E >> 0] ^ B[I + Q >> 0], Q = Q + 1 | 0;
            } while (32 != (0 | Q));

            P(A, g + 64 | 0, 128, 0), PI(A + 208 | 0), E = 128 + (Q = g + 64 | 0) | 0;

            do {
              C[Q >> 2] = 1549556828, Q = Q + 4 | 0;
            } while ((0 | Q) < (0 | E));

            B[g + 64 >> 0] = 92 ^ B[I >> 0], Q = 1;

            do {
              B[(E = g + 64 + Q | 0) >> 0] = B[E >> 0] ^ B[I + Q >> 0], Q = Q + 1 | 0;
            } while (32 != (0 | Q));

            P(A + 208 | 0, g + 64 | 0, 128, 0), MI(g + 64 | 0, 128), MI(g, 64), y = g;
          }

          function lA(A, I, g) {
            var B, Q, E, i, e, o, c, a, n;
            A |= 0, g |= 0, n = (0 | C[4 + (I |= 0) >> 2]) - (0 | C[g + 4 >> 2]) | 0, a = (0 | C[I + 8 >> 2]) - (0 | C[g + 8 >> 2]) | 0, c = (0 | C[I + 12 >> 2]) - (0 | C[g + 12 >> 2]) | 0, o = (0 | C[I + 16 >> 2]) - (0 | C[g + 16 >> 2]) | 0, e = (0 | C[I + 20 >> 2]) - (0 | C[g + 20 >> 2]) | 0, i = (0 | C[I + 24 >> 2]) - (0 | C[g + 24 >> 2]) | 0, E = (0 | C[I + 28 >> 2]) - (0 | C[g + 28 >> 2]) | 0, Q = (0 | C[I + 32 >> 2]) - (0 | C[g + 32 >> 2]) | 0, B = (0 | C[I + 36 >> 2]) - (0 | C[g + 36 >> 2]) | 0, C[A >> 2] = (0 | C[I >> 2]) - (0 | C[g >> 2]), C[A + 4 >> 2] = n, C[A + 8 >> 2] = a, C[A + 12 >> 2] = c, C[A + 16 >> 2] = o, C[A + 20 >> 2] = e, C[A + 24 >> 2] = i, C[A + 28 >> 2] = E, C[A + 32 >> 2] = Q, C[A + 36 >> 2] = B;
          }

          function _A(A, I, g) {
            var B, Q, E, i, e, o, c, a, n;
            A |= 0, I |= 0, n = (0 | C[4 + (g |= 0) >> 2]) + (0 | C[I + 4 >> 2]) | 0, a = (0 | C[g + 8 >> 2]) + (0 | C[I + 8 >> 2]) | 0, c = (0 | C[g + 12 >> 2]) + (0 | C[I + 12 >> 2]) | 0, o = (0 | C[g + 16 >> 2]) + (0 | C[I + 16 >> 2]) | 0, e = (0 | C[g + 20 >> 2]) + (0 | C[I + 20 >> 2]) | 0, i = (0 | C[g + 24 >> 2]) + (0 | C[I + 24 >> 2]) | 0, E = (0 | C[g + 28 >> 2]) + (0 | C[I + 28 >> 2]) | 0, Q = (0 | C[g + 32 >> 2]) + (0 | C[I + 32 >> 2]) | 0, B = (0 | C[g + 36 >> 2]) + (0 | C[I + 36 >> 2]) | 0, C[A >> 2] = (0 | C[g >> 2]) + (0 | C[I >> 2]), C[A + 4 >> 2] = n, C[A + 8 >> 2] = a, C[A + 12 >> 2] = c, C[A + 16 >> 2] = o, C[A + 20 >> 2] = e, C[A + 24 >> 2] = i, C[A + 28 >> 2] = E, C[A + 32 >> 2] = Q, C[A + 36 >> 2] = B;
          }

          function GA(A) {
            A |= 0;
            var I,
                g,
                C = 0,
                E = 0,
                i = 0,
                e = 0;
            I = y, g = y = y + 63 & -64, y = y + 16 | 0, B[g >> 0] = 0, B[g + 1 >> 0] = 0, B[g + 2 >> 0] = 0, B[g + 3 >> 0] = 0, B[g + 4 >> 0] = 0, B[g + 5 >> 0] = 0, B[g + 6 >> 0] = 0, i = 0;

            do {
              C = 0 | B[A + i >> 0], E = 0;

              do {
                B[(e = g + E | 0) >> 0] = B[e >> 0] | B[32096 + (E << 5) + i >> 0] ^ C, E = E + 1 | 0;
              } while (7 != (0 | E));

              i = i + 1 | 0;
            } while (31 != (0 | i));

            C = 127 & B[A + 31 >> 0], E = 0;

            do {
              B[(e = g + E | 0) >> 0] = B[e >> 0] | C ^ B[32096 + (E << 5) + 31 >> 0], E = E + 1 | 0;
            } while (7 != (0 | E));

            C = 0, E = 0;

            do {
              E = (0 | Q[g + C >> 0]) - 1 | E, C = C + 1 | 0;
            } while (7 != (0 | C));

            return y = I, E >>> 8 & 1 | 0;
          }

          function dA(A, I, g, B, Q, E, i, e, o, c, a, n) {
            return A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, o |= 0, c |= 0, c = y, y = y + 336 | 0, QB(c, a |= 0, n |= 0), gB(c + 64 | 0, c), MI(c, 64), bg(c + 64 | 0, i, e, o), LI(c + 320 | 0, e, o), bg(c + 64 | 0, c + 320 | 0, 8, 0), zI(A, B, Q, E, a, n), bg(c + 64 | 0, A, Q, E), LI(c + 320 | 0, Q, E), bg(c + 64 | 0, c + 320 | 0, 8, 0), IB(c + 64 | 0, I), MI(c + 64 | 0, 256), 0 | g && (C[g >> 2] = 16, C[g + 4 >> 2] = 0), y = c, 0;
          }

          function YA(A, I, g) {
            I |= 0;
            var Q,
                E = 0;

            if (Q = (A |= 0) + (g |= 0) | 0, I &= 255, (0 | g) >= 67) {
              for (; 3 & A;) {
                B[A >> 0] = I, A = A + 1 | 0;
              }

              for (E = I | I << 8 | I << 16 | I << 24; (0 | A) <= ((-4 & Q) - 64 | 0);) {
                C[A >> 2] = E, C[A + 4 >> 2] = E, C[A + 8 >> 2] = E, C[A + 12 >> 2] = E, C[A + 16 >> 2] = E, C[A + 20 >> 2] = E, C[A + 24 >> 2] = E, C[A + 28 >> 2] = E, C[A + 32 >> 2] = E, C[A + 36 >> 2] = E, C[A + 40 >> 2] = E, C[A + 44 >> 2] = E, C[A + 48 >> 2] = E, C[A + 52 >> 2] = E, C[A + 56 >> 2] = E, C[A + 60 >> 2] = E, A = A + 64 | 0;
              }

              for (; (0 | A) < (-4 & Q | 0);) {
                C[A >> 2] = E, A = A + 4 | 0;
              }
            }

            for (; (0 | A) < (0 | Q);) {
              B[A >> 0] = I, A = A + 1 | 0;
            }

            return Q - g | 0;
          }

          function MA(A, I) {
            A |= 0;
            var g = 0;
            g = 67108863 & (0 | Vg(I |= 0)), C[A >> 2] = g, g = (0 | Vg(I + 3 | 0)) >>> 2 & 67108611, C[A + 4 >> 2] = g, g = (0 | Vg(I + 6 | 0)) >>> 4 & 67092735, C[A + 8 >> 2] = g, g = (0 | Vg(I + 9 | 0)) >>> 6 & 66076671, C[A + 12 >> 2] = g, g = (0 | Vg(I + 12 | 0)) >>> 8 & 1048575, C[A + 16 >> 2] = g, C[A + 20 >> 2] = 0, C[A + 20 + 4 >> 2] = 0, C[A + 20 + 8 >> 2] = 0, C[A + 20 + 12 >> 2] = 0, C[A + 20 + 16 >> 2] = 0, g = 0 | Vg(I + 16 | 0), C[A + 40 >> 2] = g, g = 0 | Vg(I + 20 | 0), C[A + 44 >> 2] = g, g = 0 | Vg(I + 24 | 0), C[A + 48 >> 2] = g, I = 0 | Vg(I + 28 | 0), C[A + 52 >> 2] = I, C[A + 56 >> 2] = 0, C[A + 56 + 4 >> 2] = 0, B[A + 80 >> 0] = 0;
          }

          function SA(A, I, g, B, Q, E) {
            A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0;
            var i = 0,
                e = 0,
                c = 0;

            do {
              if (Q >>> 0 < 0 | 0 == (0 | Q) & B >>> 0 < 64 || (i = 0 | vg(0 | B, 0 | Q, -64, -1), (e = 0 | o()) >>> 0 > 0 | 0 == (0 | e) & i >>> 0 > 4294967231)) c = 10;else {
                if (0 | dg(g, g + 64 | 0, i, e, E)) {
                  if (!A) {
                    c = 10;
                    break;
                  }

                  YA(0 | A, 0, 0 | i), c = 10;
                  break;
                }

                0 | I && (C[I >> 2] = i, C[I + 4 >> 2] = e), A ? (YI(0 | A, g + 64 | 0, 0 | i), B = 0) : B = 0;
              }
            } while (0);

            return 10 == (0 | c) && (I ? (C[I >> 2] = 0, C[I + 4 >> 2] = 0, B = -1) : B = -1), 0 | B;
          }

          function UA(A, I) {
            I |= 0;
            var g,
                Q,
                E = 0,
                i = 0;

            if (g = y, Q = y = y + 63 & -64, y = y + 32 | 0, 0 | (A |= 0) && 0 | (E = 0 | C[A + 28 >> 2])) {
              C[Q >> 2] = I, i = 0;

              do {
                if (B[Q + 8 >> 0] = i, E) {
                  I = 0;

                  do {
                    C[Q + 4 >> 2] = I, C[Q + 12 >> 2] = 0, C[Q + 16 >> 2] = C[Q >> 2], C[Q + 16 + 4 >> 2] = C[Q + 4 >> 2], C[Q + 16 + 8 >> 2] = C[Q + 8 >> 2], C[Q + 16 + 12 >> 2] = C[Q + 12 >> 2], X(A, Q + 16 | 0), I = I + 1 | 0, E = 0 | C[A + 28 >> 2];
                  } while (I >>> 0 < E >>> 0);
                } else E = 0;

                i = i + 1 | 0;
              } while (4 != (0 | i));
            }

            y = g;
          }

          function vA(A, I, g, Q) {
            A |= 0, g |= 0, Q |= 0;
            var E,
                i,
                e = 0;

            if (E = y, i = y = y + 63 & -64, y = y + 192 | 0, ((I |= 0) - 1 & 255) > 63 && SB(), !((Q + -1 & 255) > 63 | 0 == (0 | g))) {
              B[i + 128 >> 0] = I, B[i + 128 + 1 >> 0] = Q, B[i + 128 + 2 >> 0] = 1, B[i + 128 + 3 >> 0] = 1, Wg(i + 128 + 4 | 0), LI(i + 128 + 8 | 0, 0, 0), e = 48 + (I = i + 128 + 16 | 0) | 0;

              do {
                C[I >> 2] = 0, I = I + 4 | 0;
              } while ((0 | I) < (0 | e));

              return XA(A, i + 128 | 0), YA(i + (255 & Q) | 0, 0, 128 - (255 & Q) | 0), BA(0 | i, 0 | g, 255 & Q | 0), $(A, i, 128, 0), MI(i, 128), void (y = E);
            }

            SB();
          }

          function bA(A, I) {
            A |= 0, I |= 0;
            var g,
                B,
                Q = 0;
            B = y, g = y = y + 63 & -64, y = y + 16 | 0;

            do {
              if (0 != (0 | A) && 0 != (0 | I) && 1024 == (0 | (I << 10 >>> 0) / (I >>> 0)) && (Q = 0 | F(12), C[A >> 2] = Q, 0 != (0 | Q))) {
                if (C[Q + 4 >> 2] = 0, C[Q >> 2] = 0, Q = 0 | wg(g, I << 10), C[8678] = Q, Q) C[g >> 2] = 0;else if (0 | (Q = 0 | C[g >> 2])) {
                  C[C[A >> 2] >> 2] = Q, C[4 + (0 | C[A >> 2]) >> 2] = Q, C[8 + (0 | C[A >> 2]) >> 2] = I << 10, Q = 0;
                  break;
                }
                d(0 | C[A >> 2]), C[A >> 2] = 0, Q = -22;
              } else Q = -22;
            } while (0);

            return y = B, 0 | Q;
          }

          function JA(A, I, g, B, E, i) {
            var e, o, c;
            return A |= 0, I |= 0, g |= 0, B |= 0, i |= 0, o = y, e = y = y + 63 & -64, y = y + 32 | 0, c = Q[4 + (E |= 0) >> 0] | Q[E + 4 + 1 >> 0] << 8 | Q[E + 4 + 2 >> 0] << 16 | Q[E + 4 + 3 >> 0] << 24, C[e + 16 >> 2] = Q[E >> 0] | Q[E + 1 >> 0] << 8 | Q[E + 2 >> 0] << 16 | Q[E + 3 >> 0] << 24, C[e + 16 + 4 >> 2] = c, C[e + 16 + 8 >> 2] = 0, C[e + 16 + 8 + 4 >> 2] = 0, LI(e, g, B), C[e + 8 >> 2] = 0, C[e + 8 + 4 >> 2] = 0, (I + -16 | 0) >>> 0 > 48 ? (C[8678] = 28, g = -1) : g = 0 | function (A, I, g, B, C) {
              return g |= 0, ((I |= 0) - 1 | 0) >>> 0 > 63 ? g = -1 : (function (A, I, g, B, C) {
                var Q, E;
                if (I |= 0, g |= 0, B |= 0, C |= 0, Q = y, E = y = y + 63 & -64, y = y + 368 | 0, (A |= 0) || SB(), (g + -1 & 255) > 63 && SB(), I) return cA(E, g, I, B, C), $(E, 0, 0, 0), b(E, A, g), void (y = Q);
                SB();
              }(A |= 0, g, 255 & I, B |= 0, C |= 0), g = 0), 0 | g;
            }(A, I, i, e, e + 16 | 0), y = o, 0 | g;
          }

          function PA(A, I, g, B, E, i, e, c, a, n, r) {
            var t;
            return A |= 0, I |= 0, g |= 0, B |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, r |= 0, t = y, y = y + 48 | 0, C[t + 32 >> 2] = 0, R(t, n, r), I = Q[n + 16 + 4 >> 0] | Q[n + 16 + 4 + 1 >> 0] << 8 | Q[n + 16 + 4 + 2 >> 0] << 16 | Q[n + 16 + 4 + 3 >> 0] << 24, C[t + 32 + 4 >> 2] = Q[n + 16 >> 0] | Q[n + 16 + 1 >> 0] << 8 | Q[n + 16 + 2 >> 0] << 16 | Q[n + 16 + 3 >> 0] << 24, C[t + 32 + 4 + 4 >> 2] = I, I = 0 | function (A, I, g, B, C, Q, E, i, e, c) {
              var a;
              A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0, i |= 0, a = y, y = y + 352 | 0, gg(a + 16 | 0, 64, 0, e |= 0, c |= 0), gB(a + 80 | 0, a + 16 | 0), MI(a + 16 | 0, 64), bg(a + 80 | 0, Q, E, i), Q = 0 | Ug(0, 0, 0 | E, 0 | i), o(), bg(a + 80 | 0, 34640, 15 & Q, 0), bg(a + 80 | 0, I, g, B), Q = 0 | Ug(0, 0, 0 | g, 0 | B), o(), bg(a + 80 | 0, 34640, 15 & Q, 0), LI(a + 336 | 0, E, i), bg(a + 80 | 0, a + 336 | 0, 8, 0), LI(a + 336 | 0, g, B), bg(a + 80 | 0, a + 336 | 0, 8, 0), IB(a + 80 | 0, a), MI(a + 80 | 0, 256), E = 0 | tB(a, C), MI(a, 16);

              do {
                if (A) {
                  if (E) {
                    YA(0 | A, 0, 0 | g), E = -1;
                    break;
                  }

                  mI(A, I, g, B, e, 1, c), E = 0;
                  break;
                }
              } while (0);

              return y = a, 0 | E;
            }(A, g, B, E, i, e, c, a, t + 32 | 0, t), MI(t, 32), y = t, 0 | I;
          }

          function RA(A, I, g, Q, E, i, e) {
            I |= 0, g |= 0, Q |= 0, E |= 0, i |= 0, e |= 0;
            var o,
                c,
                a,
                n = 0;
            a = y, o = y = y + 63 & -64, y = y + 16 | 0, c = 128 + (n = A |= 0) | 0;

            do {
              B[n >> 0] = 0, n = n + 1 | 0;
            } while ((0 | n) < (0 | c));

            do {
              if (!((i | Q) >>> 0 > 0 | 0 == (i | Q | 0) & (E | g) >>> 0 > 4294967295 | e >>> 0 > 2147483648)) {
                if (i >>> 0 < 0 | 0 == (0 | i) & E >>> 0 < 3 | e >>> 0 < 8192) {
                  C[8678] = 28, g = -1;
                  break;
                }

                Cg(o, 16), g = (0 != (0 | Gg(E, e >>> 10, I, g, o, A))) << 31 >> 31;
                break;
              }

              C[8678] = 22, g = -1;
            } while (0);

            return y = a, 0 | g;
          }

          function NA(A, I, g, B, E, i, e, c, a, n, r, t) {
            return A |= 0, I |= 0, g |= 0, B |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, r |= 0, t |= 0, n = y, y = y + 48 | 0, C[n + 32 >> 2] = 0, R(n, r, t), t = Q[r + 16 + 4 >> 0] | Q[r + 16 + 4 + 1 >> 0] << 8 | Q[r + 16 + 4 + 2 >> 0] << 16 | Q[r + 16 + 4 + 3 >> 0] << 24, C[n + 32 + 4 >> 2] = Q[r + 16 >> 0] | Q[r + 16 + 1 >> 0] << 8 | Q[r + 16 + 2 >> 0] << 16 | Q[r + 16 + 3 >> 0] << 24, C[n + 32 + 4 + 4 >> 2] = t, function (A, I, g, B, Q, E, i, e, c, a, n) {
              var r;
              A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, c |= 0, r = y, y = y + 336 | 0, gg(r, 64, 0, a |= 0, n |= 0), gB(r + 64 | 0, r), MI(r, 64), bg(r + 64 | 0, i, e, c), i = 0 | Ug(0, 0, 0 | e, 0 | c), o(), bg(r + 64 | 0, 34640, 15 & i, 0), mI(A, B, Q, E, a, 1, n), bg(r + 64 | 0, A, Q, E), a = 0 | Ug(0, 0, 0 | Q, 0 | E), o(), bg(r + 64 | 0, 34640, 15 & a, 0), LI(r + 320 | 0, e, c), bg(r + 64 | 0, r + 320 | 0, 8, 0), LI(r + 320 | 0, Q, E), bg(r + 64 | 0, r + 320 | 0, 8, 0), IB(r + 64 | 0, I), MI(r + 64 | 0, 256), 0 | g && (C[g >> 2] = 16, C[g + 4 >> 2] = 0), y = r;
            }(A, I, g, B, E, i, e, c, a, n + 32 | 0, n), MI(n, 32), y = n, 0;
          }

          function mA(A, I, g, Q, E) {
            A |= 0, I |= 0, g |= 0, Q |= 0, E |= 0;
            var i = 0,
                e = 0;

            A: do {
              if (E) {
                for (e = 0 | C[g >> 2];;) {
                  if (e >>> 0 >= I >>> 0) {
                    i = 4;
                    break;
                  }

                  if ((i = 0 | B[A + e >> 0]) << 24 >> 24 != 61) {
                    if (!Q) {
                      i = 9;
                      break;
                    }

                    if (!(0 | qg(Q, i << 24 >> 24))) {
                      i = 9;
                      break;
                    }
                  } else E = E + -1 | 0;

                  if (e = e + 1 | 0, C[g >> 2] = e, !E) {
                    E = 0;
                    break A;
                  }
                }

                if (4 == (0 | i)) {
                  C[8678] = 68, E = -1;
                  break;
                }

                if (9 == (0 | i)) {
                  C[8678] = 28, E = -1;
                  break;
                }
              } else E = 0;
            } while (0);

            return 0 | E;
          }

          function LA(A, I, g, Q, E, i, e) {
            I |= 0, g |= 0, Q |= 0, E |= 0, i |= 0, e |= 0;
            var o,
                c,
                a,
                n = 0;
            a = y, o = y = y + 63 & -64, y = y + 16 | 0, c = 128 + (n = A |= 0) | 0;

            do {
              B[n >> 0] = 0, n = n + 1 | 0;
            } while ((0 | n) < (0 | c));

            do {
              if (!((i | Q) >>> 0 > 0 | 0 == (i | Q | 0) & (E | g) >>> 0 > 4294967295 | e >>> 0 > 2147483648)) {
                if (0 == (0 | E) & 0 == (0 | i) | e >>> 0 < 8192) {
                  C[8678] = 28, g = -1;
                  break;
                }

                Cg(o, 16), g = (0 != (0 | lg(E, e >>> 10, I, g, o, A))) << 31 >> 31;
                break;
              }

              C[8678] = 22, g = -1;
            } while (0);

            return y = a, 0 | g;
          }

          function xA(A, I) {
            var g, B, Q, E, i, e, o, c, a;
            A |= 0, a = 0 - (0 | C[4 + (I |= 0) >> 2]) | 0, c = 0 - (0 | C[I + 8 >> 2]) | 0, o = 0 - (0 | C[I + 12 >> 2]) | 0, e = 0 - (0 | C[I + 16 >> 2]) | 0, i = 0 - (0 | C[I + 20 >> 2]) | 0, E = 0 - (0 | C[I + 24 >> 2]) | 0, Q = 0 - (0 | C[I + 28 >> 2]) | 0, B = 0 - (0 | C[I + 32 >> 2]) | 0, g = 0 - (0 | C[I + 36 >> 2]) | 0, C[A >> 2] = 0 - (0 | C[I >> 2]), C[A + 4 >> 2] = a, C[A + 8 >> 2] = c, C[A + 12 >> 2] = o, C[A + 16 >> 2] = e, C[A + 20 >> 2] = i, C[A + 24 >> 2] = E, C[A + 28 >> 2] = Q, C[A + 32 >> 2] = B, C[A + 36 >> 2] = g;
          }

          function KA(A, I) {
            A |= 0;
            var g,
                B,
                Q = 0;

            if (g = y, B = y = y + 63 & -64, y = y + 1024 | 0, 0 | C[28 + (I |= 0) >> 2]) {
              Q = 0;

              do {
                Pg(A + 64 | 0, 0), Pg(A + 68 | 0, Q), T(B, 1024, A, 72), xI((0 | C[4 + (0 | C[I >> 2]) >> 2]) + ((0 | E(0 | C[I + 24 >> 2], Q)) << 10) | 0, B), Pg(A + 64 | 0, 1), T(B, 1024, A, 72), xI((0 | C[4 + (0 | C[I >> 2]) >> 2]) + (1 + (0 | E(0 | C[I + 24 >> 2], Q)) << 10) | 0, B), Q = Q + 1 | 0;
              } while (Q >>> 0 < (0 | C[I + 28 >> 2]) >>> 0);
            }

            MI(B, 1024), y = g;
          }

          function XA(A, I) {
            I |= 0;
            var g = 0,
                C = 0,
                E = 0,
                i = 0;
            !function (A) {
              var I,
                  g = 0,
                  C = 0;
              C = 32352, I = 64 + (g = A |= 0) | 0;

              do {
                B[g >> 0] = 0 | B[C >> 0], g = g + 1 | 0, C = C + 1 | 0;
              } while ((0 | g) < (0 | I));

              YA(A + 64 | 0, 0, 293);
            }(A |= 0), g = 0;

            do {
              i = 0 | qI(I + (g << 3) | 0), E = 0 | o(), i = (Q[(C = A + (g << 3) | 0) >> 0] | Q[C + 1 >> 0] << 8 | Q[C + 2 >> 0] << 16 | Q[C + 3 >> 0] << 24) ^ i, E = (Q[C + 4 >> 0] | Q[C + 4 + 1 >> 0] << 8 | Q[C + 4 + 2 >> 0] << 16 | Q[C + 4 + 3 >> 0] << 24) ^ E, B[C >> 0] = i, B[C + 1 >> 0] = i >> 8, B[C + 2 >> 0] = i >> 16, B[C + 3 >> 0] = i >> 24, B[C + 4 >> 0] = E, B[C + 4 + 1 >> 0] = E >> 8, B[C + 4 + 2 >> 0] = E >> 16, B[C + 4 + 3 >> 0] = E >> 24, g = g + 1 | 0;
            } while (8 != (0 | g));
          }

          function jA(A) {
            var I,
                g,
                B,
                C,
                E,
                i,
                c = 0;
            return E = 0 | Q[7 + (A |= 0) >> 0], i = 0 | rg(0 | Q[A + 6 >> 0], 0, 8), c = 0 | o(), C = 0 | rg(0 | Q[A + 5 >> 0], 0, 16), c = 0 | c | o(), B = 0 | rg(0 | Q[A + 4 >> 0], 0, 24), c = 0 | (c = 0 | c | o()) | Q[A + 3 >> 0], g = 0 | rg(0 | Q[A + 2 >> 0], 0, 40), c = 0 | c | o(), I = 0 | rg(0 | Q[A + 1 >> 0], 0, 48), c = 0 | c | o(), A = 0 | rg(0 | Q[A >> 0], 0, 56), e(0 | c | o() | 0), i | E | C | B | g | I | A | 0;
          }

          function TA(A, I, g, B, Q, E) {
            I |= 0, Q |= 0, E |= 0;
            var i,
                e = 0;
            return i = y, e = y = y + 63 & -64, y = y + 16 | 0, YI(64 + (A |= 0) | 0, 0 | (g |= 0), 0 | (B |= 0)), kg(A, e, A + 64 | 0, B, Q, E), 64 == (0 | C[e >> 2]) & 0 == (0 | C[e + 4 >> 2]) ? 0 | I ? (e = 0 | vg(0 | B, 0 | Q, 64, 0), B = 0 | o(), C[I >> 2] = e, C[I + 4 >> 2] = B, B = 0) : B = 0 : (0 | I && (C[I >> 2] = 0, C[I + 4 >> 2] = 0), YA(0 | A, 0, B + 64 | 0), B = -1), y = i, 0 | B;
          }

          function qA(A, I) {
            I |= 0;
            var g,
                Q = 0,
                E = 0,
                i = 0,
                e = 0;
            g = 0 | B[(A |= 0) >> 0];

            A: do {
              if ((g + -48 & 255) <= 9) {
                for (E = g, i = 0, e = A;;) {
                  if (!(i >>> 0 < 429496730 & ((E = (E << 24 >> 24) - 48 | 0) >>> 0 > ~(Q = 10 * i | 0) >>> 0 ^ 1))) {
                    Q = 0;
                    break A;
                  }

                  if (i = (E >>> 0 > ~Q >>> 0 ? 0 : E) + Q | 0, ((E = 0 | B[(Q = e + 1 | 0) >> 0]) - 48 & 255) > 9) break;
                  e = Q;
                }

                (0 | Q) != (0 | A) && (0 | e) == (0 | A) | g << 24 >> 24 != 48 ? C[I >> 2] = i : Q = 0;
              } else Q = 0;
            } while (0);

            return 0 | Q;
          }

          function VA(A) {
            return ((0 - ((0 - (95 ^ (A |= 0)) | 0) >>> 8 & 63 ^ 63 | (0 - (45 ^ A) | 0) >>> 8 & 62 ^ 62 | ((A + 65439 | 0) >>> 8 ^ 255) & A + 185 & ((122 - A | 0) >>> 8 & 255 ^ 255) | ((A + -65 | 0) >>> 8 ^ 255) & A + -65 & ((90 - A | 0) >>> 8 & 255 ^ 255) | ((A + 65488 | 0) >>> 8 ^ 255) & A + 4 & ((57 - A | 0) >>> 8 & 255 ^ 255)) | 0) >>> 8 & 255 ^ 255) & (0 - (65 ^ A) | 0) >>> 8 | (0 - (95 ^ A) | 0) >>> 8 & 63 ^ 63 | (0 - (45 ^ A) | 0) >>> 8 & 62 ^ 62 | ((A + 65439 | 0) >>> 8 ^ 255) & A + 185 & ((122 - A | 0) >>> 8 & 255 ^ 255) | ((A + -65 | 0) >>> 8 ^ 255) & A + -65 & ((90 - A | 0) >>> 8 & 255 ^ 255) | ((A + 65488 | 0) >>> 8 ^ 255) & A + 4 & ((57 - A | 0) >>> 8 & 255 ^ 255) | 0;
          }

          function zA(A) {
            return ((0 - ((0 - (47 ^ (A |= 0)) | 0) >>> 8 & 63 ^ 63 | (0 - (43 ^ A) | 0) >>> 8 & 62 ^ 62 | ((A + 65439 | 0) >>> 8 ^ 255) & A + 185 & ((122 - A | 0) >>> 8 & 255 ^ 255) | ((A + -65 | 0) >>> 8 ^ 255) & A + -65 & ((90 - A | 0) >>> 8 & 255 ^ 255) | ((A + 65488 | 0) >>> 8 ^ 255) & A + 4 & ((57 - A | 0) >>> 8 & 255 ^ 255)) | 0) >>> 8 & 255 ^ 255) & (0 - (65 ^ A) | 0) >>> 8 | (0 - (47 ^ A) | 0) >>> 8 & 63 ^ 63 | (0 - (43 ^ A) | 0) >>> 8 & 62 ^ 62 | ((A + 65439 | 0) >>> 8 ^ 255) & A + 185 & ((122 - A | 0) >>> 8 & 255 ^ 255) | ((A + -65 | 0) >>> 8 ^ 255) & A + -65 & ((90 - A | 0) >>> 8 & 255 ^ 255) | ((A + 65488 | 0) >>> 8 ^ 255) & A + 4 & ((57 - A | 0) >>> 8 & 255 ^ 255) | 0;
          }

          function WA(A, I) {
            I |= 0;
            var g = 0,
                B = 0;
            if (g = 0 | yg(0 | C[72 + (A |= 0) >> 2], 0 | C[A + 72 + 4 >> 2], 3), o(), (127 & g) >>> 0 < 112) 112 - (127 & g) | 0 && BA(A + 80 + (127 & g) | 0, 33056, 112 - (127 & g) | 0);else {
              128 - (127 & g) | 0 && BA(A + 80 + (127 & g) | 0, 33056, 128 - (127 & g) | 0), D(A, A + 80 | 0, I, I + 640 | 0), B = 112 + (g = A + 80 | 0) | 0;

              do {
                C[g >> 2] = 0, g = g + 4 | 0;
              } while ((0 | g) < (0 | B));
            }
            NI(A + 192 | 0, A + 64 | 0, 16), D(A, A + 80 | 0, I, I + 640 | 0);
          }

          function OA(A, I) {
            var g, B, Q, E, i, e, o, c, a;
            A |= 0, a = 0 | C[4 + (I |= 0) >> 2], c = 0 | C[I + 8 >> 2], o = 0 | C[I + 12 >> 2], e = 0 | C[I + 16 >> 2], i = 0 | C[I + 20 >> 2], E = 0 | C[I + 24 >> 2], Q = 0 | C[I + 28 >> 2], B = 0 | C[I + 32 >> 2], g = 0 | C[I + 36 >> 2], C[A >> 2] = C[I >> 2], C[A + 4 >> 2] = a, C[A + 8 >> 2] = c, C[A + 12 >> 2] = o, C[A + 16 >> 2] = e, C[A + 20 >> 2] = i, C[A + 24 >> 2] = E, C[A + 28 >> 2] = Q, C[A + 32 >> 2] = B, C[A + 36 >> 2] = g;
          }

          function ZA(A) {
            A |= 0;
            var I = 0,
                g = 0,
                Q = 0;

            A: do {
              if (3 & A) for (I = A, g = A;;) {
                if (!(0 | B[g >> 0])) break A;

                if (!(3 & (I = g = g + 1 | 0))) {
                  I = g, Q = 5;
                  break;
                }
              } else I = A, Q = 5;
            } while (0);

            if (5 == (0 | Q)) {
              for (; !((-2139062144 & (g = 0 | C[I >> 2]) ^ -2139062144) & g + -16843009);) {
                I = I + 4 | 0;
              }

              if ((255 & g) << 24 >> 24) do {
                I = I + 1 | 0;
              } while (0 != (0 | B[I >> 0]));
            }

            return I - A | 0;
          }

          function $A(A, I) {
            I |= 0;
            var g = 0;
            C[(A |= 0) >> 2] = 1634760805, C[A + 4 >> 2] = 857760878, C[A + 8 >> 2] = 2036477234, C[A + 12 >> 2] = 1797285236, g = 0 | Vg(I), C[A + 16 >> 2] = g, g = 0 | Vg(I + 4 | 0), C[A + 20 >> 2] = g, g = 0 | Vg(I + 8 | 0), C[A + 24 >> 2] = g, g = 0 | Vg(I + 12 | 0), C[A + 28 >> 2] = g, g = 0 | Vg(I + 16 | 0), C[A + 32 >> 2] = g, g = 0 | Vg(I + 20 | 0), C[A + 36 >> 2] = g, g = 0 | Vg(I + 24 | 0), C[A + 40 >> 2] = g, I = 0 | Vg(I + 28 | 0), C[A + 44 >> 2] = I;
          }

          function AI(A, I, g) {
            I |= 0, g |= 0;
            var C = 0;
            B[7 + (A |= 0) >> 0] = I, C = 0 | yg(0 | I, 0 | g, 8), o(), B[A + 6 >> 0] = C, C = 0 | yg(0 | I, 0 | g, 16), o(), B[A + 5 >> 0] = C, C = 0 | yg(0 | I, 0 | g, 24), o(), B[A + 4 >> 0] = C, B[A + 3 >> 0] = g, C = 0 | yg(0 | I, 0 | g, 40), o(), B[A + 2 >> 0] = C, C = 0 | yg(0 | I, 0 | g, 48), o(), B[A + 1 >> 0] = C, g = 0 | yg(0 | I, 0 | g, 56), o(), B[A >> 0] = g;
          }

          function II(A, I, g) {
            var B, C;
            g |= 0, B = y, C = y = y + 63 & -64, y = y + 48 | 0, _A(A |= 0, 40 + (I |= 0) | 0, I), lA(A + 40 | 0, I + 40 | 0, I), u(A + 80 | 0, A, g + 40 | 0), u(A + 40 | 0, A + 40 | 0, g), u(A + 120 | 0, g + 120 | 0, I + 120 | 0), u(A, I + 80 | 0, g + 80 | 0), _A(C, A, A), lA(A, A + 80 | 0, A + 40 | 0), _A(A + 40 | 0, A + 80 | 0, A + 40 | 0), lA(A + 80 | 0, C, A + 120 | 0), _A(A + 120 | 0, C, A + 120 | 0), y = B;
          }

          function gI(A, I, g) {
            var B, C;
            g |= 0, B = y, C = y = y + 63 & -64, y = y + 48 | 0, _A(A |= 0, 40 + (I |= 0) | 0, I), lA(A + 40 | 0, I + 40 | 0, I), u(A + 80 | 0, A, g), u(A + 40 | 0, A + 40 | 0, g + 40 | 0), u(A + 120 | 0, g + 120 | 0, I + 120 | 0), u(A, I + 80 | 0, g + 80 | 0), _A(C, A, A), lA(A, A + 80 | 0, A + 40 | 0), _A(A + 40 | 0, A + 80 | 0, A + 40 | 0), _A(A + 80 | 0, C, A + 120 | 0), lA(A + 120 | 0, C, A + 120 | 0), y = B;
          }

          function BI(A, I, g) {
            var B, C;
            g |= 0, B = y, C = y = y + 63 & -64, y = y + 48 | 0, _A(A |= 0, 40 + (I |= 0) | 0, I), lA(A + 40 | 0, I + 40 | 0, I), u(A + 80 | 0, A, g + 40 | 0), u(A + 40 | 0, A + 40 | 0, g), u(A + 120 | 0, g + 80 | 0, I + 120 | 0), _A(C, I + 80 | 0, I + 80 | 0), lA(A, A + 80 | 0, A + 40 | 0), _A(A + 40 | 0, A + 80 | 0, A + 40 | 0), lA(A + 80 | 0, C, A + 120 | 0), _A(A + 120 | 0, C, A + 120 | 0), y = B;
          }

          function CI(A, I, g) {
            var B, C;
            g |= 0, B = y, C = y = y + 63 & -64, y = y + 48 | 0, _A(A |= 0, 40 + (I |= 0) | 0, I), lA(A + 40 | 0, I + 40 | 0, I), u(A + 80 | 0, A, g), u(A + 40 | 0, A + 40 | 0, g + 40 | 0), u(A + 120 | 0, g + 80 | 0, I + 120 | 0), _A(C, I + 80 | 0, I + 80 | 0), lA(A, A + 80 | 0, A + 40 | 0), _A(A + 40 | 0, A + 80 | 0, A + 40 | 0), _A(A + 80 | 0, C, A + 120 | 0), lA(A + 120 | 0, C, A + 120 | 0), y = B;
          }

          function QI(A, I) {
            A |= 0, I |= 0;
            var g,
                C,
                Q = 0;
            g = y, C = y = y + 63 & -64, y = y + 208 | 0, Q = 0;

            do {
              B[A + Q >> 0] = 0 | B[I + Q >> 0], Q = Q + 1 | 0;
            } while (32 != (0 | Q));

            return B[A >> 0] = -8 & B[A >> 0], B[A + 31 >> 0] = 63 & B[A + 31 >> 0] | 64, iA(C + 40 | 0, A), function (A, I, g) {
              var B, C;
              A |= 0, B = y, C = y = y + 63 & -64, y = y + 96 | 0, _A(C + 48 | 0, g |= 0, I |= 0), lA(C, g, I), W(C, C), u(A, C + 48 | 0, C), y = B;
            }(C, C + 40 + 40 | 0, C + 40 + 80 | 0), CA(A, C), y = g, 0;
          }

          function EI(A, I, g) {
            var E, i;

            if (A |= 0, I |= 0, g |= 0, E = y, i = y = y + 63 & -64, y = y + 16 | 0, C[i + 4 >> 2] = A, C[i >> 2] = I, B[i + 8 >> 0] = 0, 0 | g) {
              A = 0;

              do {
                B[i + 8 >> 0] = B[i + 8 >> 0] | B[(0 | C[i >> 2]) + A >> 0] ^ B[(0 | C[i + 4 >> 2]) + A >> 0], A = A + 1 | 0;
              } while ((0 | A) != (0 | g));
            }

            return y = E, ((511 + (0 | Q[i + 8 >> 0]) | 0) >>> 8 & 1) - 1 | 0;
          }

          function iI(A, I) {
            A |= 0;
            var g,
                Q,
                E = 0;

            if (g = y, Q = y = y + 63 & -64, y = y + 64 | 0, !(((I |= 0) - 1 & 255) > 63)) {
              B[Q >> 0] = I, B[Q + 1 >> 0] = 0, B[Q + 2 >> 0] = 1, B[Q + 3 >> 0] = 1, Wg(Q + 4 | 0), LI(Q + 8 | 0, 0, 0), E = 48 + (I = Q + 16 | 0) | 0;

              do {
                C[I >> 2] = 0, I = I + 4 | 0;
              } while ((0 | I) < (0 | E));

              return XA(A, Q), void (y = g);
            }

            SB();
          }

          function eI(A, I, g) {
            var Q, E;
            A |= 0, I |= 0, g |= 0, Q = y, E = y = y + 63 & -64, y = y + 16 | 0, C[E + 8 >> 2] = A, C[E + 4 >> 2] = I, C[E >> 2] = 0, A = 0;

            do {
              C[E >> 2] = C[E >> 2] | 255 & (B[(0 | C[E + 4 >> 2]) + A >> 0] ^ B[(0 | C[E + 8 >> 2]) + A >> 0]), A = A + 1 | 0;
            } while ((0 | A) != (0 | g));

            return y = Q, ((511 + (0 | C[E >> 2]) | 0) >>> 8 & 1) - 1 | 0;
          }

          function oI(A, I, g) {
            I |= 0, g |= 0;
            var C = 0,
                E = 0;
            C = 0 | B[(A |= 0) >> 0];

            A: do {
              if (C << 24 >> 24) for (;;) {
                if (g = g + -1 | 0, !(C << 24 >> 24 == (E = 0 | B[I >> 0]) << 24 >> 24 & 0 != (0 | g) & E << 24 >> 24 != 0)) break A;

                if (I = I + 1 | 0, !((C = 0 | B[(A = A + 1 | 0) >> 0]) << 24 >> 24)) {
                  C = 0;
                  break;
                }
              } else C = 0;
            } while (0);

            return (255 & C) - (0 | Q[I >> 0]) | 0;
          }

          function cI(A, I) {
            A |= 0, I |= 0;
            var g,
                C,
                Q = 0,
                i = 0,
                e = 0,
                o = 0;

            for (g = y, C = y = y + 63 & -64, y = y + 16 | 0, i = 10; o = 255 & ((e = I) + (0 | E(I = (I >>> 0) / 10 | 0, -10)) | 48), B[C + (Q = i + -1 | 0) >> 0] = o, e >>> 0 > 9 & 0 != (0 | Q);) {
              i = Q;
            }

            BA(0 | A, C + Q | 0, 0 | (o = 11 - i | 0)), B[A + o >> 0] = 0, y = g;
          }

          function aI(A, I) {
            var g, B;
            g = y, B = y = y + 63 & -64, y = y + 48 | 0, _(A |= 0, I |= 0), _(A + 80 | 0, I + 40 | 0), l(A + 120 | 0, I + 80 | 0), _A(A + 40 | 0, I, I + 40 | 0), _(B, A + 40 | 0), _A(A + 40 | 0, A + 80 | 0, A), lA(A + 80 | 0, A + 80 | 0, A), lA(A, B, A + 40 | 0), lA(A + 120 | 0, A + 120 | 0, A + 80 | 0), y = g;
          }

          function nI(A, I, g) {
            var C, E;
            if (A |= 0, I |= 0, g |= 0, E = y, C = y = y + 63 & -64, y = y + 16 | 0, B[C >> 0] = 0, 0 | function (A, I, g) {
              A |= 0, I |= 0;
              var C,
                  E,
                  i = 0;
              if (E = y, C = y = y + 63 & -64, y = y + 336 | 0, 0 | function (A) {
                A |= 0;
                var I,
                    g,
                    C = 0,
                    E = 0,
                    i = 0,
                    e = 0;
                I = y, g = y = y + 63 & -64, y = y + 16 | 0, B[g >> 0] = 0, B[g + 1 >> 0] = 0, B[g + 2 >> 0] = 0, B[g + 3 >> 0] = 0, B[g + 4 >> 0] = 0, B[g + 5 >> 0] = 0, B[g + 6 >> 0] = 0, i = 0;

                do {
                  C = 0 | B[A + i >> 0], E = 0;

                  do {
                    B[(e = g + E | 0) >> 0] = B[e >> 0] | B[33184 + (E << 5) + i >> 0] ^ C, E = E + 1 | 0;
                  } while (7 != (0 | E));

                  i = i + 1 | 0;
                } while (31 != (0 | i));

                C = 127 & B[A + 31 >> 0], E = 0;

                do {
                  B[(e = g + E | 0) >> 0] = B[e >> 0] | C ^ B[33184 + (E << 5) + 31 >> 0], E = E + 1 | 0;
                } while (7 != (0 | E));

                C = 0, E = 0;

                do {
                  E = (0 | Q[g + C >> 0]) - 1 | E, C = C + 1 | 0;
                } while (7 != (0 | C));

                return y = I, E >>> 8 & 1 | 0;
              }(g |= 0)) i = -1;else {
                i = 0;

                do {
                  B[A + i >> 0] = 0 | B[I + i >> 0], i = i + 1 | 0;
                } while (32 != (0 | i));

                for (B[A >> 0] = -8 & B[A >> 0], B[A + 31 >> 0] = 63 & B[A + 31 >> 0] | 64, U(C + 288 | 0, g), Sg(C + 240 | 0), Kg(C + 192 | 0), OA(C + 144 | 0, C + 288 | 0), Sg(C + 96 | 0), i = 254, I = 0; g = I, AA(C + 240 | 0, C + 144 | 0, g ^= I = (0 | Q[A + (i >>> 3) >> 0]) >>> (7 & i) & 1), AA(C + 192 | 0, C + 96 | 0, g), lA(C + 48 | 0, C + 144 | 0, C + 96 | 0), lA(C, C + 240 | 0, C + 192 | 0), _A(C + 240 | 0, C + 240 | 0, C + 192 | 0), _A(C + 192 | 0, C + 144 | 0, C + 96 | 0), u(C + 96 | 0, C + 48 | 0, C + 240 | 0), u(C + 192 | 0, C + 192 | 0, C), _(C + 48 | 0, C), _(C, C + 240 | 0), _A(C + 144 | 0, C + 96 | 0, C + 192 | 0), lA(C + 192 | 0, C + 96 | 0, C + 192 | 0), u(C + 240 | 0, C, C + 48 | 0), lA(C, C, C + 48 | 0), _(C + 192 | 0, C + 192 | 0), v(C + 96 | 0, C), _(C + 144 | 0, C + 144 | 0), _A(C + 48 | 0, C + 48 | 0, C + 96 | 0), u(C + 96 | 0, C + 288 | 0, C + 192 | 0), u(C + 192 | 0, C, C + 48 | 0), i;) {
                  i = i + -1 | 0;
                }

                AA(C + 240 | 0, C + 144 | 0, I), AA(C + 192 | 0, C + 96 | 0, I), W(C + 192 | 0, C + 192 | 0), u(C + 240 | 0, C + 240 | 0, C + 192 | 0), CA(A, C + 240 | 0), i = 0;
              }
              return y = E, 0 | i;
            }(A, I, g)) I = -1;else {
              I = 0;

              do {
                B[C >> 0] = B[C >> 0] | B[A + I >> 0], I = I + 1 | 0;
              } while (32 != (0 | I));

              I = 0 - ((511 + (0 | Q[C >> 0]) | 0) >>> 8 & 1) | 0;
            }
            return y = E, 0 | I;
          }

          function rI(A, I, g, B, C, Q, E) {
            A |= 0, I |= 0, C |= 0, Q |= 0, E |= 0;
            var i,
                e = 0;
            e = 0 | Ug(0, 1, 0 | (e = 0 | yg(0 | (e = 0 | vg(0 | (g |= 0), 0 | (B |= 0), 63, 0)), 0 | o(), 6)), 0 | o()), (i = 0 | o()) >>> 0 < 0 | 0 == (0 | i) & e >>> 0 < Q >>> 0 ? SB() : mI(A, I, g, B, C, Q, E);
          }

          function tI(A, I, g) {
            A |= 0, I |= 0;
            var C,
                Q,
                E = 0,
                i = 0;
            Q = y, i = y = y + 63 & -64, y = y + 64 | 0, RI(i, g |= 0, 32, 0), E = i, C = (g = I) + 32 | 0;

            do {
              B[g >> 0] = 0 | B[E >> 0], g = g + 1 | 0, E = E + 1 | 0;
            } while ((0 | g) < (0 | C));

            return MI(i, 64), i = 0 | AB(A, I), y = Q, 0 | i;
          }

          function fI(A, I, g, B, C, Q, E) {
            var i, e;
            A |= 0, I |= 0, C |= 0, E |= 0, i = y, e = y = y + 63 & -64, y = y + 80 | 0, 0 == (0 | (g |= 0)) & 0 == (0 | (B |= 0)) || (Pg(e + 64 | 0, Q |= 0), $A(e, E), UI(e, C, e + 64 | 0), M(e, I, A, g, B), MI(e, 64)), y = i;
          }

          function wI(A, I, g) {
            var C, Q;
            A |= 0, C = y, Q = y = y + 63 & -64, y = y + 160 | 0, RI(I |= 0, g |= 0, 32, 0), B[I >> 0] = -8 & B[I >> 0], B[I + 31 >> 0] = 63 & B[I + 31 >> 0] | 64, iA(Q, I), sI(A, Q), YI(0 | I, 0 | g, 32), YI(I + 32 | 0, 0 | A, 32), y = C;
          }

          function yI(A, I, g, B) {
            A |= 0, I |= 0, g |= 0, B |= 0;

            A: do {
              if (B >>> 0 > 0 | 0 == (0 | B) & g >>> 0 > 4294967295) C[8678] = 22, g = -1;else {
                switch (0 | oB(A, I, g)) {
                  case 0:
                    g = 0;
                    break A;

                  case -35:
                    C[8678] = 28;
                }

                g = -1;
              }
            } while (0);

            return 0 | g;
          }

          function sI(A, I) {
            var g, C;
            A |= 0, g = y, C = y = y + 63 & -64, y = y + 144 | 0, W(C + 96 | 0, 80 + (I |= 0) | 0), u(C + 48 | 0, I, C + 96 | 0), u(C, I + 40 | 0, C + 96 | 0), CA(A, C), I = (0 | sg(C + 48 | 0)) << 7, B[A + 31 >> 0] = I ^ (0 | Q[A + 31 >> 0]), y = g;
          }

          function hI(A, I, g, B) {
            A |= 0, I |= 0, g |= 0, B |= 0;

            A: do {
              if (B >>> 0 > 0 | 0 == (0 | B) & g >>> 0 > 4294967295) C[8678] = 22, g = -1;else {
                switch (0 | cB(A, I, g)) {
                  case 0:
                    g = 0;
                    break A;

                  case -35:
                    C[8678] = 28;
                }

                g = -1;
              }
            } while (0);

            return 0 | g;
          }

          function DI(A, I, g, B, C, Q, E, i) {
            var e;
            return A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, e = y, y = y + 32 | 0, 0 | jg(e, E |= 0, i |= 0) ? B = -1 : (B = 0 | ng(A, I, g, B, C, Q, e), MI(e, 32)), y = e, 0 | B;
          }

          function FI(A, I, g, B, C, Q, E, i) {
            var e;
            return A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, e = y, y = y + 32 | 0, 0 | jg(e, E |= 0, i |= 0) ? B = -1 : (tg(A, I, g, B, C, Q, e), MI(e, 32), B = 0), y = e, 0 | B;
          }

          function pI(A) {
            A |= 0;
            var I = 0,
                g = 0,
                C = 0,
                Q = 0,
                E = 0;

            for (Q = 0, E = 32, I = 1; Q = (255 & (g = 0 | B[A + (E = E + -1 | 0) >> 0])) - (255 & (C = 0 | B[32320 + E >> 0])) >> 8 & (I &= 255) | 255 & Q, E;) {
              I &= (65535 + (255 & (C ^ g)) | 0) >>> 8;
            }

            return 0 != (0 | Q) | 0;
          }

          function uI(A, I, g, B) {
            return B = 0 | vg(0 | vg(0 | (g |= 0), 0 | (B |= 0), 0 | (A |= 0), 0 | (I |= 0)), 0 | o(), 0 | (B = 0 | Qg(-2 & (B = 0 | rg(0 | A, 0 | I, 1)) | 0, 1 & (0 | o()) | 0, 0 | g, 0)), 0 | o()), e(0 | o()), 0 | B;
          }

          function HI(A, I, g, B) {
            A |= 0, I |= 0, g |= 0, B |= 0;

            do {
              if (!(g >>> 0 > 64 | (B + -1 | 0) >>> 0 > 63)) {
                if (0 == (0 | I) | 0 == (0 | g)) {
                  iI(A, 255 & B), I = 0;
                  break;
                }

                vA(A, 255 & B, I, 255 & g), I = 0;
                break;
              }

              I = -1;
            } while (0);

            return 0 | I;
          }

          function kI(A) {
            var I,
                g,
                B,
                C = 0;
            return g = 0 | Q[(A |= 0) >> 0], B = 0 | rg(0 | Q[A + 1 >> 0], 0, 8), C = 0 | o(), I = 0 | rg(0 | Q[A + 2 >> 0], 0, 16), C = 0 | C | o(), A = 0 | rg(0 | Q[A + 3 >> 0], 0, 24), e(0 | C | o() | 0), B | g | I | A | 0;
          }

          function lI(A, I) {
            A |= 0, I |= 0;
            var g,
                C,
                E = 0;
            g = y, C = y = y + 63 & -64, y = y + 16 | 0, B[C >> 0] = 0, E = 0;

            do {
              B[C >> 0] = B[C >> 0] | B[A + E >> 0], E = E + 1 | 0;
            } while ((0 | E) != (0 | I));

            return y = g, (511 + (0 | Q[C >> 0]) | 0) >>> 8 & 1 | 0;
          }

          function _I(A, I, g) {
            A |= 0, I |= 0;
            var B = 0;
            (g |= 0) ? (B = 0 | Vg(g), C[A + 48 >> 2] = B, g = 0 | Vg(g + 4 | 0)) : (C[A + 48 >> 2] = 0, g = 0), C[A + 52 >> 2] = g, B = 0 | Vg(I), C[A + 56 >> 2] = B, B = 0 | Vg(I + 4 | 0), C[A + 60 >> 2] = B;
          }

          function GI(A, I, g) {
            var B, C;
            A |= 0, I |= 0, g |= 0, B = y, C = y = y + 63 & -64, y = y + 384 | 0, Lg(C, 0, 0, 24), Rg(C, I, 32, 0), Rg(C, g, 32, 0), zg(C, A, 24), y = B;
          }

          function dI(A, I, g, B, C, Q, E) {
            return I |= 0, C |= 0, Q |= 0, E |= 0, 0 | ((B |= 0) >>> 0 < 0 | 0 == (0 | B) & (g |= 0) >>> 0 < 16 ? -1 : 0 | DI(A |= 0, I + 16 | 0, I, g = 0 | vg(0 | g, 0 | B, -16, -1), 0 | o(), C, Q, E));
          }

          function YI(A, I, g) {
            var C = 0;

            if ((0 | (I |= 0)) < (0 | (A |= 0)) & (0 | A) < (I + (g |= 0) | 0)) {
              for (C = A, I = I + g | 0, A = A + g | 0; (0 | g) > 0;) {
                I = I - 1 | 0, g = g - 1 | 0, B[(A = A - 1 | 0) >> 0] = 0 | B[I >> 0];
              }

              A = C;
            } else BA(A, I, g);

            return 0 | A;
          }

          function MI(A, I) {
            var g, Q;

            if (A |= 0, I |= 0, g = y, Q = y = y + 63 & -64, y = y + 16 | 0, C[Q >> 2] = A, 0 | I) {
              A = 0;

              do {
                B[(0 | C[Q >> 2]) + A >> 0] = 0, A = A + 1 | 0;
              } while ((0 | A) != (0 | I));
            }

            y = g;
          }

          function SI(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                B = 0,
                Q = 0,
                E = 0;
            g = 0;

            do {
              E = I + (g << 3) | 0, Q = C[4 + (B = A + (g << 3) | 0) >> 2] ^ C[E + 4 >> 2], C[B >> 2] = C[B >> 2] ^ C[E >> 2], C[B + 4 >> 2] = Q, g = g + 1 | 0;
            } while (128 != (0 | g));
          }

          function UI(A, I, g) {
            A |= 0, I |= 0, g = (g |= 0) ? 0 | Vg(g) : 0, C[A + 48 >> 2] = g, g = 0 | Vg(I), C[A + 52 >> 2] = g, g = 0 | Vg(I + 4 | 0), C[A + 56 >> 2] = g, I = 0 | Vg(I + 8 | 0), C[A + 60 >> 2] = I;
          }

          function vI(A, I) {
            var g, C;
            I |= 0, C = y, y = y + 64 | 0, function (A, I) {
              var g;
              I |= 0, g = y, y = y + 64 | 0, VI(A |= 0, g), P(A + 208 | 0, g, 64, 0), VI(A + 208 | 0, I), MI(g, 64), y = g;
            }(A |= 0, C), A = C, g = I + 32 | 0;

            do {
              B[I >> 0] = 0 | B[A >> 0], I = I + 1 | 0, A = A + 1 | 0;
            } while ((0 | I) < (0 | g));

            y = C;
          }

          function bI(A) {
            var I;
            return A |= 0, ((I = 0 | C[8808]) + A | 0) >>> 0 > (0 | r()) >>> 0 && 0 == (0 | f(I + A | 0)) ? (C[8678] = 48, 0 | (A = -1)) : (C[8808] = I + A, 0 | (A = I));
          }

          function JI(A, I, g, B, C) {
            var Q;
            A |= 0, I |= 0, g |= 0, B |= 0, Q = y, y = y + 416 | 0, function (A, I) {
              kA(A |= 0, I |= 0);
            }(Q, C |= 0), function (A, I, g, B) {
              xg(A |= 0, I |= 0, g |= 0, B |= 0);
            }(Q, I, g, B), vI(Q, A), y = Q;
          }

          function PI(A) {
            var I,
                g = 0;
            C[64 + (A |= 0) >> 2] = 0, C[A + 64 + 4 >> 2] = 0, C[A + 64 + 8 >> 2] = 0, C[A + 64 + 12 >> 2] = 0, g = 32352, I = A + 64 | 0;

            do {
              C[A >> 2] = C[g >> 2], A = A + 4 | 0, g = g + 4 | 0;
            } while ((0 | A) < (0 | I));
          }

          function RI(A, I, g, B) {
            var C, Q;
            A |= 0, I |= 0, g |= 0, B |= 0, C = y, Q = y = y + 63 & -64, y = y + 208 | 0, PI(Q), P(Q, I, g, B), VI(Q, A), y = C;
          }

          function NI(A, I, g) {
            A |= 0, I |= 0;
            var B = 0,
                Q = 0;

            if ((g |= 0) >>> 3 | 0) {
              B = 0;

              do {
                AI(A + (B << 3) | 0, 0 | C[(Q = I + (B << 3) | 0) >> 2], 0 | C[Q + 4 >> 2]), B = B + 1 | 0;
              } while ((0 | B) != (g >>> 3 | 0));
            }
          }

          function mI(A, I, g, B, C, Q, E) {
            A |= 0, I |= 0, C |= 0, Q |= 0, E |= 0, (B |= 0) >>> 0 > 0 | 0 == (0 | B) & (g |= 0) >>> 0 > 4294967295 ? SB() : fI(A, I, g, B, C, Q, E);
          }

          function LI(A, I, g) {
            I |= 0, g |= 0, B[(A |= 0) >> 0] = I, B[A + 1 >> 0] = I >> 8, B[A + 2 >> 0] = I >> 16, B[A + 3 >> 0] = I >> 24, B[A + 4 >> 0] = g, B[A + 4 + 1 >> 0] = g >> 8, B[A + 4 + 2 >> 0] = g >> 16, B[A + 4 + 3 >> 0] = g >> 24;
          }

          function xI(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                B = 0,
                Q = 0,
                E = 0;
            g = 0;

            do {
              E = 0 | qI(I + (g << 3) | 0), Q = 0 | o(), C[(B = A + (g << 3) | 0) >> 2] = E, C[B + 4 >> 2] = Q, g = g + 1 | 0;
            } while (128 != (0 | g));
          }

          function KI(A, I, g, B, C, Q, E) {
            return A |= 0, I |= 0, C |= 0, Q |= 0, E |= 0, (B |= 0) >>> 0 > 0 | 0 == (0 | B) & (g |= 0) >>> 0 > 4294967279 ? (SB(), 0) : 0 | FI(A + 16 | 0, A, I, g, B, C, Q, E);
          }

          function XI(A) {
            return (0 - (62 ^ (A |= 0)) | 0) >>> 8 & 45 ^ 45 | (A + 65510 | 0) >>> 8 & 255 & A + 65 | (0 - (63 ^ A) | 0) >>> 8 & 95 ^ 95 | (A + 65484 | 0) >>> 8 & A + 71 & ((A + 65510 | 0) >>> 8 & 255 ^ 255) | (A + 65474 | 0) >>> 8 & A + 252 & ((A + 65484 | 0) >>> 8 & 255 ^ 255) | 0;
          }

          function jI(A) {
            return (0 - (62 ^ (A |= 0)) | 0) >>> 8 & 43 ^ 43 | (A + 65510 | 0) >>> 8 & 255 & A + 65 | (0 - (63 ^ A) | 0) >>> 8 & 47 ^ 47 | (A + 65484 | 0) >>> 8 & A + 71 & ((A + 65510 | 0) >>> 8 & 255 ^ 255) | (A + 65474 | 0) >>> 8 & A + 252 & ((A + 65484 | 0) >>> 8 & 255 ^ 255) | 0;
          }

          function TI(A, I, g, B, C, Q, E) {
            return B |= 0, ((I |= 0) - 1 | 0) >>> 0 > 63 | (E |= 0) >>> 0 > 64 ? B = -1 : (function (A, I, g, B, C, Q, E) {
              var i, e;
              A |= 0, g |= 0, B |= 0, E |= 0, i = y, e = y = y + 63 & -64, y = y + 368 | 0, 0 == (0 | (I |= 0)) & (0 != (0 | (C |= 0)) | 0 != (0 | (Q |= 0))) && SB(), A || SB(), (B + -1 & 255) > 63 && SB(), 0 != (0 | g) | E << 24 >> 24 == 0 || SB(), (255 & E) > 64 && SB(), E << 24 >> 24 ? vA(e, B, g, E) : iI(e, B), $(e, I, C, Q), b(e, A, B), y = i;
            }(A |= 0, g |= 0, Q |= 0, 255 & I, B, C |= 0, 255 & E), B = 0), 0 | B;
          }

          function qI(A) {
            var I;
            return I = Q[(A |= 0) >> 0] | Q[A + 1 >> 0] << 8 | Q[A + 2 >> 0] << 16 | Q[A + 3 >> 0] << 24, e(Q[A + 4 >> 0] | Q[A + 4 + 1 >> 0] << 8 | Q[A + 4 + 2 >> 0] << 16 | Q[A + 4 + 3 >> 0] << 24 | 0), 0 | I;
          }

          function VI(A, I) {
            var g, B;
            I |= 0, g = y, B = y = y + 63 & -64, y = y + 704 | 0, WA(A |= 0, B), NI(I, A, 64), MI(B, 704), MI(A, 208), y = g;
          }

          function zI(A, I, g, B, C, Q) {
            A |= 0, I |= 0, C |= 0, Q |= 0, (B |= 0) >>> 0 > 0 | 0 == (0 | B) & (g |= 0) >>> 0 > 4294967295 ? SB() : function (A, I, g, B, C, Q, E, i) {
              var e, o;
              A |= 0, I |= 0, C |= 0, i |= 0, e = y, o = y = y + 63 & -64, y = y + 80 | 0, 0 == (0 | (g |= 0)) & 0 == (0 | (B |= 0)) || (Pg(o + 64 | 0, 1), Pg(o + 64 + 4 | 0, 0), $A(o, i), _I(o, C, o + 64 | 0), M(o, I, A, g, B), MI(o, 64)), y = e;
            }(A, I, g, B, C, 0, 0, Q);
          }

          function WI(A) {
            var I = 0,
                g = 0;
            I = 127 & B[31 + (A |= 0) >> 0] ^ 127, g = 30;

            do {
              I |= ~B[A + g >> 0], g = g + -1 | 0;
            } while (0 != (0 | g));

            return (236 - (0 | Q[A >> 0]) & 511 + (255 & I)) >>> 8 & 1 ^ 1 | 0;
          }

          function OI(A, I, g, B, C) {
            A |= 0, B |= 0, C |= 0, (g |= 0) >>> 0 > 0 | 0 == (0 | g) & (I |= 0) >>> 0 > 4294967295 ? SB() : gg(A, I, g, B, C);
          }

          function ZI(A, I, g) {
            var B, C;
            return B = 0 | yg(0 | (A |= 0), 0 | (I |= 0), 0 | (g |= 0)), C = 0 | o(), g = 0 | rg(0 | A, 0 | I, 64 - g | 0), e(0 | o() | C | 0), g | B | 0;
          }

          function $I(A, I, g) {
            var B, C;
            return B = 0 | rg(0 | (A |= 0), 0 | (I |= 0), 0 | (g |= 0)), C = 0 | o(), g = 0 | yg(0 | A, 0 | I, 64 - g | 0), e(0 | o() | C | 0), g | B | 0;
          }

          function Ag(A, I, g, B) {
            var Q;
            return Q = y, y = y + 16 | 0, function (A, I, g, B, Q) {
              A |= 0, g |= 0, B |= 0, Q |= 0;
              var E = 0,
                  c = 0,
                  a = 0,
                  n = 0,
                  r = 0,
                  t = 0,
                  f = 0,
                  w = 0,
                  y = 0,
                  s = 0;
              if (!(I |= 0)) return B ? Q ? (C[Q >> 2] = 0 | A, C[Q + 4 >> 2] = 0 & I, Q = 0, 0 | (e(0 | (B = 0)), Q)) : (Q = 0, 0 | (e(0 | (B = 0)), Q)) : (0 | Q && (C[Q >> 2] = (A >>> 0) % (g >>> 0), C[Q + 4 >> 2] = 0), Q = (A >>> 0) / (g >>> 0) >>> 0, 0 | (e(0 | (B = 0)), Q));

              do {
                if (g) {
                  if (0 | B) {
                    if ((c = (0 | i(0 | B)) - (0 | i(0 | I)) | 0) >>> 0 <= 31) {
                      w = c + 1 | 0, a = A >>> ((c + 1 | 0) >>> 0) & c - 31 >> 31 | I << 31 - c, f = I >>> ((c + 1 | 0) >>> 0) & c - 31 >> 31, E = 0, c = A << 31 - c;
                      break;
                    }

                    return Q ? (C[Q >> 2] = 0 | A, C[Q + 4 >> 2] = I | 0 & I, Q = 0, 0 | (e(0 | (B = 0)), Q)) : (Q = 0, 0 | (e(0 | (B = 0)), Q));
                  }

                  if (g - 1 & g | 0) {
                    w = c = 33 + (0 | i(0 | g)) - (0 | i(0 | I)) | 0, a = 32 - c - 1 >> 31 & I >>> ((c - 32 | 0) >>> 0) | (I << 32 - c | A >>> (c >>> 0)) & c - 32 >> 31, f = c - 32 >> 31 & I >>> (c >>> 0), E = A << 64 - c & 32 - c >> 31, c = (I << 64 - c | A >>> ((c - 32 | 0) >>> 0)) & 32 - c >> 31 | A << 32 - c & c - 33 >> 31;
                    break;
                  }

                  return 0 | Q && (C[Q >> 2] = g - 1 & A, C[Q + 4 >> 2] = 0), 1 == (0 | g) ? (Q = 0 | A, 0 | (e(0 | (B = I | 0 & I)), Q)) : (B = I >>> ((Q = 0 | nB(0 | g)) >>> 0) | 0, Q = I << 32 - Q | A >>> (Q >>> 0) | 0, 0 | (e(0 | B), Q));
                }

                if (!B) return 0 | Q && (C[Q >> 2] = (I >>> 0) % (g >>> 0), C[Q + 4 >> 2] = 0), Q = (I >>> 0) / (g >>> 0) >>> 0, 0 | (e(0 | (B = 0)), Q);
                if (!A) return 0 | Q && (C[Q >> 2] = 0, C[Q + 4 >> 2] = (I >>> 0) % (B >>> 0)), Q = (I >>> 0) / (B >>> 0) >>> 0, 0 | (e(0 | (g = 0)), Q);
                if (!(B - 1 & B)) return 0 | Q && (C[Q >> 2] = 0 | A, C[Q + 4 >> 2] = B - 1 & I | 0 & I), g = 0, Q = I >>> ((0 | nB(0 | B)) >>> 0), 0 | (e(0 | g), Q);

                if ((c = (0 | i(0 | B)) - (0 | i(0 | I)) | 0) >>> 0 <= 30) {
                  w = c + 1 | 0, a = I << 31 - c | A >>> ((c + 1 | 0) >>> 0), f = I >>> ((c + 1 | 0) >>> 0), E = 0, c = A << 31 - c;
                  break;
                }

                return Q ? (C[Q >> 2] = 0 | A, C[Q + 4 >> 2] = I | 0 & I, Q = 0, 0 | (e(0 | (B = 0)), Q)) : (Q = 0, 0 | (e(0 | (B = 0)), Q));
              } while (0);

              if (w) {
                r = 0 | vg(0 | g, B | 0 & B | 0, -1, -1), t = 0 | o(), n = c, I = f, A = w, c = 0;

                do {
                  s = n, n = E >>> 31 | n << 1, E = c | E << 1, Ug(0 | r, 0 | t, 0 | (s = a << 1 | s >>> 31 | 0), 0 | (y = a >>> 31 | I << 1 | 0)), c = 1 & (f = (w = 0 | o()) >> 31 | ((0 | w) < 0 ? -1 : 0) << 1), a = 0 | Ug(0 | s, 0 | y, f & (0 | g) | 0, (((0 | w) < 0 ? -1 : 0) >> 31 | ((0 | w) < 0 ? -1 : 0) << 1) & (B | 0 & B) | 0), I = 0 | o(), A = A - 1 | 0;
                } while (0 != (0 | A));

                A = 0;
              } else n = c, I = f, A = 0, c = 0;

              0 | Q && (C[Q >> 2] = a, C[Q + 4 >> 2] = I), s = -2 & (E << 1 | 0) | c, e(0 | (y = (0 | E) >>> 31 | n << 1 | 0 & (0 | E >>> 31) | A));
            }(A |= 0, I |= 0, g |= 0, B |= 0, 0 | Q), y = Q, 0 | (e(0 | C[Q + 4 >> 2]), 0 | C[Q >> 2]);
          }

          function Ig(A) {
            A |= 0;
            var I = 0,
                g = 0,
                C = 0;

            for (I = 1, g = 0; I = I + (0 | Q[(C = A + g | 0) >> 0]) | 0, B[C >> 0] = I, 4 != (0 | (g = g + 1 | 0));) {
              I >>>= 8;
            }
          }

          function gg(A, I, g, B, C) {
            A |= 0, B |= 0, C |= 0, (g |= 0) >>> 0 > 0 | 0 == (0 | g) & (I |= 0) >>> 0 > 4294967295 ? SB() : function (A, I, g, B, C) {
              var Q, E;
              A |= 0, B |= 0, Q = y, E = y = y + 63 & -64, y = y + 64 | 0, 0 == (0 | (I |= 0)) & 0 == (0 | (g |= 0)) || ($A(E, C |= 0), UI(E, B, 0), YA(0 | A, 0, 0 | I), M(E, A, A, I, g), MI(E, 64)), y = Q;
            }(A, I, g, B, C);
          }

          function Bg(A, I, g) {
            var B;
            return A |= 0, g |= 0, I = 0 | rg(255 & (I |= 0) | 0, 0, 8), B = 0 | o(), g = 0 | rg(255 & g | 0, 0, 16), e(0 | B | o() | 0), I | 255 & A | g | 0;
          }

          function Cg(A, I) {
            A |= 0;
            var g = 0,
                C = 0;

            if (0 | (I |= 0)) {
              g = 0;

              do {
                C = 255 & (0 | DB()), B[A + g >> 0] = C, g = g + 1 | 0;
              } while ((0 | g) != (0 | I));
            }
          }

          function Qg(A, I, g, B) {
            var C, Q;
            return I |= 0, B |= 0, C = 0 | function (A, I) {
              var g, B, C;
              return C = ((g = 0 | E(65535 & (I |= 0), 65535 & (A |= 0))) >>> 16) + (0 | E(65535 & I, A >>> 16)) | 0, B = 0 | E(I >>> 16, 65535 & A), 0 | (e((C >>> 16) + (0 | E(I >>> 16, A >>> 16)) + (((65535 & C) + B | 0) >>> 16) | 0), C + B << 16 | 65535 & g | 0);
            }(A |= 0, g |= 0), Q = 0 | o(), 0 | (e((0 | E(I, g)) + (0 | E(B, A)) + Q | 0 & Q | 0), 0 | C);
          }

          function Eg(A, I) {
            u(A |= 0, I |= 0, I + 120 | 0), u(A + 40 | 0, I + 40 | 0, I + 80 | 0), u(A + 80 | 0, I + 80 | 0, I + 120 | 0), u(A + 120 | 0, I, I + 40 | 0);
          }

          function ig(A, I, g) {
            return A |= 0, I |= 0, (0 | (g |= 0)) < 32 ? (e(I >> g | 0), A >>> g | (I & (1 << g) - 1) << 32 - g) : (e(0 | ((0 | I) < 0 ? -1 : 0)), I >> g - 32 | 0);
          }

          function eg(A, I) {
            _A(A |= 0, 40 + (I |= 0) | 0, I), lA(A + 40 | 0, I + 40 | 0, I), OA(A + 80 | 0, I + 80 | 0), u(A + 120 | 0, I + 120 | 0, 112);
          }

          function og(A, I) {
            var g, B;
            A |= 0, g = y, B = y = y + 63 & -64, y = y + 128 | 0, function (A, I) {
              OA(A |= 0, I |= 0), OA(A + 40 | 0, I + 40 | 0), OA(A + 80 | 0, I + 80 | 0);
            }(B, I |= 0), aI(A, B), y = g;
          }

          function cg(A) {
            var I, g;
            return I = y, g = y = y + 63 & -64, y = y + 32 | 0, CA(g, A |= 0), A = 0 | lI(g, 32), y = I, 0 | A;
          }

          function ag(A, I) {
            A |= 0, I |= 0;
            var g = 0,
                C = 0;
            g = 0;

            do {
              B[(C = A + g | 0) >> 0] = B[C >> 0] ^ B[I + g >> 0], g = g + 1 | 0;
            } while (8 != (0 | g));
          }

          function ng(A, I, g, B, C, Q, E) {
            return 0 | gA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0);
          }

          function rg(A, I, g) {
            return A |= 0, (0 | (g |= 0)) < 32 ? (e((I |= 0) << g | (A & (1 << g) - 1 << 32 - g) >>> 32 - g | 0), A << g) : (e(A << g - 32 | 0), 0);
          }

          function tg(A, I, g, B, C, Q, E) {
            return Z(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0), 0;
          }

          function fg(A, I, g) {
            return (g |= 0) >>> 0 < 256 ? 0 | b(A |= 0, I |= 0, 255 & g) : (c(33547, 33567, 107, 33620), 0);
          }

          function wg(A, I) {
            A |= 0;
            var g = 0;
            return (I |= 0) >>> 0 <= 4294967168 && 0 != (0 | (g = 0 | function (A) {
              var I,
                  g = 0,
                  B = 0,
                  Q = 0,
                  E = 0;
              if ((A |= 0) >>> 0 >= 4294967168) return C[8678] = 48, 0;
              if (!(B = 0 | F(76 + (I = A >>> 0 < 11 ? 16 : A + 11 & -8) | 0))) return 0;

              do {
                if (63 & B) {
                  if (g = (Q = ((B + 63 & -64) - 8 - (B + -8) | 0) >>> 0 > 15 ? (B + 63 & -64) - 8 | 0 : 56 + (B + 63 & -64) | 0) - (B + -8) | 0, 3 & (A = 0 | C[B + -4 >> 2])) {
                    C[Q + 4 >> 2] = (-8 & A) - g | 1 & C[Q + 4 >> 2] | 2, C[Q + ((-8 & A) - g) + 4 >> 2] = 1 | C[Q + ((-8 & A) - g) + 4 >> 2], C[B + -4 >> 2] = g | 1 & C[B + -4 >> 2] | 2, C[Q + 4 >> 2] = 1 | C[Q + 4 >> 2], Y(B + -8 | 0, g), E = Q, A = Q;
                    break;
                  }

                  C[Q >> 2] = (0 | C[B + -8 >> 2]) + g, C[Q + 4 >> 2] = (-8 & A) - g, E = Q, A = Q;
                  break;
                }

                E = B + -8 | 0, A = B + -8 | 0;
              } while (0);

              return 3 & (A = 0 | C[(g = A + 4 | 0) >> 2]) | 0 && (-8 & A) >>> 0 > (I + 16 | 0) >>> 0 && (Q = E + I | 0, C[g >> 2] = I | 1 & A | 2, C[Q + 4 >> 2] = (-8 & A) - I | 3, C[(B = E + (-8 & A) + 4 | 0) >> 2] = 1 | C[B >> 2], Y(Q, (-8 & A) - I | 0)), 0 | E + 8;
            }(I))) ? (C[A >> 2] = g, I = 0) : I = 48, 0 | I;
          }

          function yg(A, I, g) {
            return A |= 0, I |= 0, (0 | (g |= 0)) < 32 ? (e(I >>> g | 0), A >>> g | (I & (1 << g) - 1) << 32 - g) : (e(0), I >>> g - 32 | 0);
          }

          function sg(A) {
            var I, g;
            return g = y, I = y = y + 63 & -64, y = y + 32 | 0, CA(I, A |= 0), y = g, 1 & B[I >> 0] | 0;
          }

          function hg(A, I, g) {
            tA(A |= 0, I |= 0, 255 & (g |= 0)), tA(A + 40 | 0, I + 40 | 0, 255 & g), tA(A + 80 | 0, I + 80 | 0, 255 & g);
          }

          function Dg(A, I, g, B, C, Q, E) {
            return 0 | TI(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0);
          }

          function Fg(A, I, g, B, C, Q, E) {
            return 0 | nA(A |= 0, I |= 0, 1, g |= 0, B |= 0, C |= 0, 16, Q |= 0, E |= 0, 0, 0, 2);
          }

          function pg(A, I, g, B, C, Q, E) {
            return 0 | nA(A |= 0, I |= 0, 1, g |= 0, B |= 0, C |= 0, 16, Q |= 0, E |= 0, 0, 0, 1);
          }

          function ug(A, I) {
            (function (A, I) {
              A |= 0, 0 | (I |= 0) && (0 | (I = 0 | C[A >> 2]) && MI(0 | C[I + 4 >> 2], C[A + 16 >> 2] << 10), 0 | (I = 0 | C[A + 4 >> 2]) && MI(I, C[A + 20 >> 2] << 3));
            })(A |= 0, 4 & (I |= 0)), d(0 | C[A + 4 >> 2]), C[A + 4 >> 2] = 0, function (A) {
              var I = 0;
              0 | (A |= 0) && 0 | (I = 0 | C[A >> 2]) && d(I), d(A);
            }(0 | C[A >> 2]), C[A >> 2] = 0;
          }

          function Hg(A, I) {
            u(A |= 0, I |= 0, I + 120 | 0), u(A + 40 | 0, I + 40 | 0, I + 80 | 0), u(A + 80 | 0, I + 80 | 0, I + 120 | 0);
          }

          function kg(A, I, g, B, C, Q) {
            hA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, 0);
          }

          function lg(A, I, g, B, C, Q) {
            return 0 | nA(A |= 0, I |= 0, 1, g |= 0, B |= 0, C |= 0, 16, 0, 32, Q |= 0, 128, 2);
          }

          function _g(A, I, g, B, C, Q) {
            V(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, 1, 0, Q |= 0);
          }

          function Gg(A, I, g, B, C, Q) {
            return 0 | nA(A |= 0, I |= 0, 1, g |= 0, B |= 0, C |= 0, 16, 0, 32, Q |= 0, 128, 1);
          }

          function dg(A, I, g, B, C) {
            return 0 | uA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, 0);
          }

          function Yg(A, I, g, B, C, Q) {
            V(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, 0, 0, Q |= 0);
          }

          function Mg(A) {
            B[32 + (A |= 0) >> 0] = 1, B[A + 32 + 1 >> 0] = 0, B[A + 32 + 2 >> 0] = 0, B[A + 32 + 3 >> 0] = 0;
          }

          function Sg(A) {
            var I;
            C[(A |= 0) >> 2] = 1, I = 36 + (A = A + 4 | 0) | 0;

            do {
              C[A >> 2] = 0, A = A + 4 | 0;
            } while ((0 | A) < (0 | I));
          }

          function Ug(A, I, g, B) {
            return 0 | (e(0 | (B = (I |= 0) - (B |= 0) - ((g |= 0) >>> 0 > (A |= 0) >>> 0 | 0) >>> 0)), A - g >>> 0 | 0);
          }

          function vg(A, I, g, B) {
            return 0 | (e((I |= 0) + (B |= 0) + ((A |= 0) + (g |= 0) >>> 0 >>> 0 < A >>> 0 | 0) >>> 0 | 0), A + g >>> 0 | 0);
          }

          function bg(A, I, g, B) {
            !function (A, I, g, B) {
              K(A |= 0, I |= 0, g |= 0, B |= 0);
            }(A |= 0, I |= 0, g |= 0, B |= 0);
          }

          function Jg(A, I) {
            I |= 0, PI(A |= 0), 0 | I && P(A, 33408, 34, 0);
          }

          function Pg(A, I) {
            I |= 0, B[(A |= 0) >> 0] = I, B[A + 1 >> 0] = I >> 8, B[A + 2 >> 0] = I >> 16, B[A + 3 >> 0] = I >> 24;
          }

          function Rg(A, I, g, B) {
            return Xg(A |= 0, I |= 0, g |= 0, B |= 0), 0;
          }

          function Ng(A, I, g, B) {
            return 0 | FA(A |= 0, I |= 0, g |= 0, B |= 0, 2);
          }

          function mg(A, I, g, B) {
            return 0 | FA(A |= 0, I |= 0, g |= 0, B |= 0, 1);
          }

          function Lg(A, I, g, B) {
            return 0 | HI(A |= 0, I |= 0, g |= 0, B |= 0);
          }

          function xg(A, I, g, B) {
            P(A |= 0, I |= 0, g |= 0, B |= 0);
          }

          function Kg(A) {
            var I;
            I = 40 + (A |= 0) | 0;

            do {
              C[A >> 2] = 0, A = A + 4 | 0;
            } while ((0 | A) < (0 | I));
          }

          function Xg(A, I, g, B) {
            $(A |= 0, I |= 0, g |= 0, B |= 0);
          }

          function jg(A, I, g) {
            return 0 | function (A, I, g) {
              var B, C;
              return A |= 0, C = y, B = y = y + 63 & -64, y = y + 32 | 0, 0 | nI(B, g |= 0, I |= 0) ? A = -1 : (x(A, 34656, B), A = 0), y = C, 0 | A;
            }(A |= 0, I |= 0, g |= 0);
          }

          function Tg(A) {
            B[(A |= 0) >> 0] = -8 & B[A >> 0], B[A + 31 >> 0] = 63 & B[A + 31 >> 0] | 64;
          }

          function qg(A, I) {
            return A = 0 | HA(A |= 0, I |= 0), 0 | ((0 | B[A >> 0]) == (255 & I) << 24 >> 24 ? A : 0);
          }

          function Vg(A) {
            return Q[(A |= 0) >> 0] | Q[A + 1 >> 0] << 8 | Q[A + 2 >> 0] << 16 | Q[A + 3 >> 0] << 24 | 0;
          }

          function zg(A, I, g) {
            return 0 | fg(A |= 0, I |= 0, g |= 0);
          }

          function Wg(A) {
            B[(A |= 0) >> 0] = 0, B[A + 1 >> 0] = 0, B[A + 2 >> 0] = 0, B[A + 3 >> 0] = 0;
          }

          function Og(A) {
            Kg(A |= 0), Sg(A + 40 | 0), Sg(A + 80 | 0), Kg(A + 120 | 0);
          }

          function Zg(A) {
            C[(A |= 0) >> 2] = 0, C[A + 4 >> 2] = 0, C[A + 8 >> 2] = 0, C[A + 12 >> 2] = 0;
          }

          function $g(A, I, g) {
            !function (A, I, g) {
              var B, C, Q;
              A |= 0, I |= 0, B = y, Q = y = y + 63 & -64, y = y + 128 | 0, g = ((g |= 0) << 24 >> 24) - ((0 - (255 & (C = 0 | function (A) {
                return (255 & (A |= 0)) >>> 7 | 0;
              }(g))) & g << 24 >> 24) << 1) & 255, function (A) {
                Sg(A |= 0), Sg(A + 40 | 0), Kg(A + 80 | 0);
              }(A), hg(A, I, 0 | aB(g, 1)), hg(A, I + 120 | 0, 0 | aB(g, 2)), hg(A, I + 240 | 0, 0 | aB(g, 3)), hg(A, I + 360 | 0, 0 | aB(g, 4)), hg(A, I + 480 | 0, 0 | aB(g, 5)), hg(A, I + 600 | 0, 0 | aB(g, 6)), hg(A, I + 720 | 0, 0 | aB(g, 7)), hg(A, I + 840 | 0, 0 | aB(g, 8)), OA(Q, A + 40 | 0), OA(Q + 40 | 0, A), xA(Q + 80 | 0, A + 80 | 0), hg(A, Q, C), y = B;
            }(A |= 0, 1120 + (960 * (I |= 0) | 0) | 0, g |= 0);
          }

          function AB(A, I) {
            return 0 | QI(A |= 0, I |= 0);
          }

          function IB(A, I) {
            !function (A, I) {
              z(A |= 0, I |= 0);
            }(A |= 0, I |= 0);
          }

          function gB(A, I) {
            !function (A, I) {
              MA(A |= 0, I |= 0);
            }(A |= 0, I |= 0);
          }

          function BB(A, I, g) {
            return 0 | nI(A |= 0, I |= 0, g |= 0);
          }

          function CB(A, I) {
            return 0 | function (A, I) {
              return A |= 0, Cg(I |= 0, 32), 0 | AB(A, I);
            }(A |= 0, I |= 0);
          }

          function QB(A, I, g) {
            !function (A, I, g, B, C) {
              var Q, E;
              A |= 0, B |= 0, Q = y, E = y = y + 63 & -64, y = y + 64 | 0, 0 == (0 | (I |= 0)) & 0 == (0 | (g |= 0)) || ($A(E, C |= 0), _I(E, B, 0), YA(0 | A, 0, 64), M(E, A, A, 64, 0), MI(E, 64)), y = Q;
            }(A |= 0, 64, 0, I |= 0, g |= 0);
          }

          function EB(A) {
            1 != (-7 & (A |= 0) | 0) && SB();
          }

          function iB(A, I, g) {
            !function (A, I, g) {
              A |= 0, I |= 0;
              var B,
                  C,
                  Q,
                  E,
                  i,
                  e,
                  o,
                  c,
                  a,
                  n,
                  r,
                  t = 0,
                  f = 0,
                  w = 0,
                  y = 0,
                  s = 0,
                  h = 0,
                  D = 0,
                  F = 0,
                  p = 0,
                  u = 0,
                  H = 0,
                  k = 0,
                  l = 0,
                  _ = 0,
                  G = 0,
                  d = 0,
                  Y = 0,
                  M = 0,
                  S = 0,
                  U = 0,
                  v = 0,
                  b = 0,
                  J = 0,
                  P = 0,
                  R = 0,
                  N = 0,
                  m = 0,
                  L = 0,
                  x = 0,
                  K = 0,
                  X = 0,
                  j = 0;
              r = 0 | Vg(g |= 0), i = 0 | Vg(g + 4 | 0), e = 0 | Vg(g + 8 | 0), o = 0 | Vg(g + 12 | 0), c = 0 | Vg(g + 16 | 0), a = 0 | Vg(g + 20 | 0), n = 0 | Vg(g + 24 | 0), B = 0 | Vg(g + 28 | 0), C = 0 | Vg(I), Q = 0 | Vg(I + 4 | 0), E = 0 | Vg(I + 8 | 0), g = 0 | Vg(I + 12 | 0), I = 0, t = 1634760805, f = r, w = 2036477234, y = c, s = a, h = n, D = B, F = 1797285236, p = i, u = e, H = o, k = 857760878, l = C, _ = Q, G = E, d = g;

              do {
                x = (0 | wB((U = (0 | wB((J = (0 | wB((N = (0 | wB(t + s | 0, 7)) ^ H) + t | 0, 9)) ^ G) + N | 0, 13)) ^ s) + J | 0, 18)) ^ t, R = (0 | wB((j = (0 | wB((S = (0 | wB((b = (0 | wB(f + k | 0, 7)) ^ d) + k | 0, 9)) ^ h) + b | 0, 13)) ^ f) + S | 0, 18)) ^ k, v = (0 | wB((L = (0 | wB((X = (0 | wB((M = (0 | wB(l + w | 0, 7)) ^ D) + w | 0, 9)) ^ p) + M | 0, 13)) ^ l) + X | 0, 18)) ^ w, Y = (0 | wB((P = (0 | wB((m = (0 | wB((K = (0 | wB(y + F | 0, 7)) ^ u) + F | 0, 9)) ^ _) + K | 0, 13)) ^ y) + m | 0, 18)) ^ F, t = (0 | wB((u = (0 | wB((p = (0 | wB((f = (0 | wB(K + x | 0, 7)) ^ j) + x | 0, 9)) ^ X) + f | 0, 13)) ^ K) + p | 0, 18)) ^ x, k = (0 | wB((H = (0 | wB((_ = (0 | wB((l = (0 | wB(R + N | 0, 7)) ^ L) + R | 0, 9)) ^ m) + l | 0, 13)) ^ N) + _ | 0, 18)) ^ R, w = (0 | wB((d = (0 | wB((G = (0 | wB((y = (0 | wB(v + b | 0, 7)) ^ P) + v | 0, 9)) ^ J) + y | 0, 13)) ^ b) + G | 0, 18)) ^ v, F = (0 | wB((D = (0 | wB((h = (0 | wB((s = (0 | wB(Y + M | 0, 7)) ^ U) + Y | 0, 9)) ^ S) + s | 0, 13)) ^ M) + h | 0, 18)) ^ Y, I = I + 2 | 0;
              } while (I >>> 0 < 20);

              Pg(A, t + 1634760805 | 0), Pg(A + 4 | 0, f + r | 0), Pg(A + 8 | 0, p + i | 0), Pg(A + 12 | 0, u + e | 0), Pg(A + 16 | 0, H + o | 0), Pg(A + 20 | 0, k + 857760878 | 0), Pg(A + 24 | 0, l + C | 0), Pg(A + 28 | 0, _ + Q | 0), Pg(A + 32 | 0, G + E | 0), Pg(A + 36 | 0, d + g | 0), Pg(A + 40 | 0, w + 2036477234 | 0), Pg(A + 44 | 0, y + c | 0), Pg(A + 48 | 0, s + a | 0), Pg(A + 52 | 0, h + n | 0), Pg(A + 56 | 0, D + B | 0), Pg(A + 60 | 0, F + 1797285236 | 0);
            }(A |= 0, I |= 0, g |= 0);
          }

          function eB(A, I) {
            return 0 | AB(A |= 0, I |= 0);
          }

          function oB(A, I, g) {
            return 0 | EA(A |= 0, I |= 0, g |= 0, 2);
          }

          function cB(A, I, g) {
            return 0 | EA(A |= 0, I |= 0, g |= 0, 1);
          }

          function aB(A, I) {
            return ((255 & ((I |= 0) ^ (A |= 0))) - 1 | 0) >>> 31 & 255 | 0;
          }

          function nB(A) {
            return 0 | ((A |= 0) ? 31 - (0 | i(A ^ A - 1)) | 0 : 32);
          }

          function rB(A, I) {
            return 0 | eI(A |= 0, I |= 0, 32);
          }

          function tB(A, I) {
            return 0 | eI(A |= 0, I |= 0, 16);
          }

          function fB(A, I) {
            BA(0 | (A |= 0), 0 | (I |= 0), 1024);
          }

          function wB(A, I) {
            return (A |= 0) >>> (32 - (I |= 0) | 0) | A << I | 0;
          }

          function yB(A) {
            YA(0 | (A |= 0), 0, 1024);
          }

          function sB(A) {
            Cg(A |= 0, 32);
          }

          function hB() {
            n(1);
          }

          function DB() {
            return 0 | n(0);
          }

          function FB() {
            return -17;
          }

          function pB() {
            return 3;
          }

          function uB() {
            return 2;
          }

          function HB() {
            return -1;
          }

          function kB() {
            return 1;
          }

          function lB() {
            return 8;
          }

          function _B() {
            return 24;
          }

          function GB() {
            return 16;
          }

          function dB() {
            return 64;
          }

          function YB() {
            return 32;
          }

          function MB() {
            return 0;
          }

          function SB() {
            a();
          }

          return {
            ___errno_location: function ___errno_location() {
              return 34712;
            },
            ___muldi3: Qg,
            ___uremdi3: Ag,
            _bitshift64Ashr: ig,
            _bitshift64Lshr: yg,
            _bitshift64Shl: rg,
            _crypto_aead_chacha20poly1305_abytes: GB,
            _crypto_aead_chacha20poly1305_decrypt: function _crypto_aead_chacha20poly1305_decrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              I |= 0, g |= 0, B |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0;
              var r = 0,
                  t = 0;
              return (E |= 0) >>> 0 > 0 | 0 == (0 | E) & (Q |= 0) >>> 0 > 15 ? (E = 0 | sA(A |= 0, 0, B, g = 0 | vg(0 | Q, 0 | E, -16, -1), r = 0 | o(), B + Q + -16 | 0, i, e, c, a, n), I && (Q = 0 == (0 | E) ? g : 0, g = 0 == (0 | E) ? r : 0, t = 4)) : I ? (Q = 0, g = 0, E = -1, t = 4) : E = -1, 4 == (0 | t) && (C[I >> 2] = Q, C[I + 4 >> 2] = g), 0 | E;
            },
            _crypto_aead_chacha20poly1305_decrypt_detached: sA,
            _crypto_aead_chacha20poly1305_encrypt: function _crypto_aead_chacha20poly1305_encrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              return A |= 0, I |= 0, g |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, (Q |= 0) >>> 0 > 0 | 0 == (0 | Q) & (B |= 0) >>> 0 > 4294967279 && SB(), dA(A, A + B | 0, 0, g, B, Q, E, i, e, 0, a, n), 0 | I && (a = 0 | vg(0 | B, 0 | Q, 16, 0), c = 0 | o(), C[I >> 2] = a, C[I + 4 >> 2] = c), 0;
            },
            _crypto_aead_chacha20poly1305_encrypt_detached: dA,
            _crypto_aead_chacha20poly1305_ietf_abytes: GB,
            _crypto_aead_chacha20poly1305_ietf_decrypt: function _crypto_aead_chacha20poly1305_ietf_decrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              I |= 0, g |= 0, B |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0;
              var r = 0,
                  t = 0;
              return (E |= 0) >>> 0 > 0 | 0 == (0 | E) & (Q |= 0) >>> 0 > 15 ? (E = 0 | eA(A |= 0, 0, B, g = 0 | vg(0 | Q, 0 | E, -16, -1), r = 0 | o(), B + Q + -16 | 0, i, e, c, a, n), I && (Q = 0 == (0 | E) ? g : 0, g = 0 == (0 | E) ? r : 0, t = 4)) : I ? (Q = 0, g = 0, E = -1, t = 4) : E = -1, 4 == (0 | t) && (C[I >> 2] = Q, C[I + 4 >> 2] = g), 0 | E;
            },
            _crypto_aead_chacha20poly1305_ietf_decrypt_detached: eA,
            _crypto_aead_chacha20poly1305_ietf_encrypt: function _crypto_aead_chacha20poly1305_ietf_encrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              return A |= 0, I |= 0, g |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, (Q |= 0) >>> 0 > 0 | 0 == (0 | Q) & (B |= 0) >>> 0 > 4294967279 && SB(), fA(A, A + B | 0, 0, g, B, Q, E, i, e, 0, a, n), 0 | I && (a = 0 | vg(0 | B, 0 | Q, 16, 0), c = 0 | o(), C[I >> 2] = a, C[I + 4 >> 2] = c), 0;
            },
            _crypto_aead_chacha20poly1305_ietf_encrypt_detached: fA,
            _crypto_aead_chacha20poly1305_ietf_keybytes: YB,
            _crypto_aead_chacha20poly1305_ietf_keygen: sB,
            _crypto_aead_chacha20poly1305_ietf_messagebytes_max: FB,
            _crypto_aead_chacha20poly1305_ietf_npubbytes: function _crypto_aead_chacha20poly1305_ietf_npubbytes() {
              return 12;
            },
            _crypto_aead_chacha20poly1305_ietf_nsecbytes: MB,
            _crypto_aead_chacha20poly1305_keybytes: YB,
            _crypto_aead_chacha20poly1305_keygen: sB,
            _crypto_aead_chacha20poly1305_messagebytes_max: FB,
            _crypto_aead_chacha20poly1305_npubbytes: lB,
            _crypto_aead_chacha20poly1305_nsecbytes: MB,
            _crypto_aead_xchacha20poly1305_ietf_abytes: GB,
            _crypto_aead_xchacha20poly1305_ietf_decrypt: function _crypto_aead_xchacha20poly1305_ietf_decrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              I |= 0, g |= 0, B |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0;
              var r = 0,
                  t = 0;
              return (E |= 0) >>> 0 > 0 | 0 == (0 | E) & (Q |= 0) >>> 0 > 15 ? (E = 0 | PA(A |= 0, 0, B, g = 0 | vg(0 | Q, 0 | E, -16, -1), r = 0 | o(), B + Q + -16 | 0, i, e, c, a, n), I && (Q = 0 == (0 | E) ? g : 0, g = 0 == (0 | E) ? r : 0, t = 4)) : I ? (Q = 0, g = 0, E = -1, t = 4) : E = -1, 4 == (0 | t) && (C[I >> 2] = Q, C[I + 4 >> 2] = g), 0 | E;
            },
            _crypto_aead_xchacha20poly1305_ietf_decrypt_detached: PA,
            _crypto_aead_xchacha20poly1305_ietf_encrypt: function _crypto_aead_xchacha20poly1305_ietf_encrypt(A, I, g, B, Q, E, i, e, c, a, n) {
              return A |= 0, I |= 0, g |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0, (Q |= 0) >>> 0 > 0 | 0 == (0 | Q) & (B |= 0) >>> 0 > 4294967279 && SB(), NA(A, A + B | 0, 0, g, B, Q, E, i, e, 0, a, n), 0 | I && (a = 0 | vg(0 | B, 0 | Q, 16, 0), c = 0 | o(), C[I >> 2] = a, C[I + 4 >> 2] = c), 0;
            },
            _crypto_aead_xchacha20poly1305_ietf_encrypt_detached: NA,
            _crypto_aead_xchacha20poly1305_ietf_keybytes: YB,
            _crypto_aead_xchacha20poly1305_ietf_keygen: sB,
            _crypto_aead_xchacha20poly1305_ietf_messagebytes_max: FB,
            _crypto_aead_xchacha20poly1305_ietf_npubbytes: _B,
            _crypto_aead_xchacha20poly1305_ietf_nsecbytes: MB,
            _crypto_auth: function _crypto_auth(A, I, g, B, C) {
              return JI(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0), 0;
            },
            _crypto_auth_bytes: YB,
            _crypto_auth_keybytes: YB,
            _crypto_auth_keygen: sB,
            _crypto_auth_verify: function _crypto_auth_verify(A, I, g, B, C) {
              return 0 | function (A, I, g, B, C) {
                var Q;
                return A |= 0, Q = y, y = y + 32 | 0, JI(Q, I |= 0, g |= 0, B |= 0, C |= 0), C = 0 | rB(A, Q), C = 0 | ((0 | Q) == (0 | A) ? -1 : C) | EI(Q, A, 32), y = Q, 0 | C;
              }(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0);
            },
            _crypto_box_beforenm: jg,
            _crypto_box_beforenmbytes: YB,
            _crypto_box_detached: FI,
            _crypto_box_detached_afternm: tg,
            _crypto_box_easy: KI,
            _crypto_box_easy_afternm: function _crypto_box_easy_afternm(A, I, g, B, C, Q) {
              return A |= 0, I |= 0, C |= 0, Q |= 0, (B |= 0) >>> 0 > 0 | 0 == (0 | B) & (g |= 0) >>> 0 > 4294967279 ? (SB(), 0) : (tg(A + 16 | 0, A, I, g, B, C, Q), 0);
            },
            _crypto_box_keypair: CB,
            _crypto_box_macbytes: GB,
            _crypto_box_messagebytes_max: FB,
            _crypto_box_noncebytes: _B,
            _crypto_box_open_detached: DI,
            _crypto_box_open_detached_afternm: ng,
            _crypto_box_open_easy: dI,
            _crypto_box_open_easy_afternm: function _crypto_box_open_easy_afternm(A, I, g, B, C, Q) {
              return I |= 0, C |= 0, Q |= 0, 0 | ((B |= 0) >>> 0 < 0 | 0 == (0 | B) & (g |= 0) >>> 0 < 16 ? -1 : 0 | ng(A |= 0, I + 16 | 0, I, g = 0 | vg(0 | g, 0 | B, -16, -1), 0 | o(), C, Q));
            },
            _crypto_box_publickeybytes: YB,
            _crypto_box_seal: function _crypto_box_seal(A, I, g, C, Q) {
              A |= 0, I |= 0, g |= 0, C |= 0, Q |= 0;
              var E,
                  i = 0,
                  e = 0,
                  o = 0;
              if (E = y, y = y + 96 | 0, 0 | CB(E + 32 | 0, E)) g = -1;else {
                e = E + 32 | 0, o = (i = A) + 32 | 0;

                do {
                  B[i >> 0] = 0 | B[e >> 0], i = i + 1 | 0, e = e + 1 | 0;
                } while ((0 | i) < (0 | o));

                GI(E + 64 | 0, E + 32 | 0, Q), g = 0 | KI(A + 32 | 0, I, g, C, E + 64 | 0, Q, E), MI(E, 32), MI(E + 32 | 0, 32), MI(E + 64 | 0, 24);
              }
              return y = E, 0 | g;
            },
            _crypto_box_seal_open: function _crypto_box_seal_open(A, I, g, B, C, Q) {
              var E, i;
              return A |= 0, I |= 0, C |= 0, Q |= 0, i = y, E = y = y + 63 & -64, y = y + 32 | 0, (B |= 0) >>> 0 < 0 | 0 == (0 | B) & (g |= 0) >>> 0 < 48 ? g = -1 : (B = 0 | vg(0 | g, 0 | B, -32, -1), g = 0 | o(), GI(E, I, C), g = 0 | dI(A, I + 32 | 0, B, g, E, I, Q)), y = i, 0 | g;
            },
            _crypto_box_sealbytes: function _crypto_box_sealbytes() {
              return 48;
            },
            _crypto_box_secretkeybytes: YB,
            _crypto_box_seed_keypair: function _crypto_box_seed_keypair(A, I, g) {
              return 0 | tI(A |= 0, I |= 0, g |= 0);
            },
            _crypto_box_seedbytes: YB,
            _crypto_generichash: Dg,
            _crypto_generichash_bytes: YB,
            _crypto_generichash_bytes_max: dB,
            _crypto_generichash_bytes_min: GB,
            _crypto_generichash_final: zg,
            _crypto_generichash_init: Lg,
            _crypto_generichash_keybytes: YB,
            _crypto_generichash_keybytes_max: dB,
            _crypto_generichash_keybytes_min: GB,
            _crypto_generichash_keygen: sB,
            _crypto_generichash_statebytes: function _crypto_generichash_statebytes() {
              return 384;
            },
            _crypto_generichash_update: Rg,
            _crypto_hash: function _crypto_hash(A, I, g, B) {
              return RI(A |= 0, I |= 0, g |= 0, B |= 0), 0;
            },
            _crypto_hash_bytes: dB,
            _crypto_kdf_bytes_max: dB,
            _crypto_kdf_bytes_min: GB,
            _crypto_kdf_contextbytes: lB,
            _crypto_kdf_derive_from_key: function _crypto_kdf_derive_from_key(A, I, g, B, C, Q) {
              return 0 | JA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0);
            },
            _crypto_kdf_keybytes: YB,
            _crypto_kdf_keygen: sB,
            _crypto_kx_client_session_keys: function _crypto_kx_client_session_keys(A, I, g, C, Q) {
              var E, i, e;
              if (I |= 0, g |= 0, C |= 0, Q |= 0, e = y, i = y = y + 63 & -64, y = y + 480 | 0, E = 0 == (0 | (A |= 0)) ? I : A, I = 0 == (0 | I) ? E : I, E || SB(), 0 | BB(i + 448 | 0, C, Q)) A = -1;else {
                Lg(i, 0, 0, 64), Rg(i, i + 448 | 0, 32, 0), MI(i + 448 | 0, 32), Rg(i, g, 32, 0), Rg(i, Q, 32, 0), zg(i, i + 384 | 0, 64), MI(i, 384), A = 0;

                do {
                  B[E + A >> 0] = 0 | B[i + 384 + A >> 0], B[I + A >> 0] = 0 | B[i + 384 + (A + 32) >> 0], A = A + 1 | 0;
                } while (32 != (0 | A));

                MI(i + 384 | 0, 64), A = 0;
              }
              return y = e, 0 | A;
            },
            _crypto_kx_keypair: function _crypto_kx_keypair(A, I) {
              return A |= 0, Cg(I |= 0, 32), 0 | eB(A, I);
            },
            _crypto_kx_publickeybytes: YB,
            _crypto_kx_secretkeybytes: YB,
            _crypto_kx_seed_keypair: function _crypto_kx_seed_keypair(A, I, g) {
              return A |= 0, Dg(I |= 0, 32, g |= 0, 32, 0, 0, 0), 0 | eB(A, I);
            },
            _crypto_kx_seedbytes: YB,
            _crypto_kx_server_session_keys: function _crypto_kx_server_session_keys(A, I, g, C, Q) {
              var E, i, e;
              if (I |= 0, g |= 0, C |= 0, Q |= 0, e = y, i = y = y + 63 & -64, y = y + 480 | 0, E = 0 == (0 | (A |= 0)) ? I : A, I = 0 == (0 | I) ? E : I, E || SB(), 0 | BB(i + 448 | 0, C, Q)) A = -1;else {
                Lg(i, 0, 0, 64), Rg(i, i + 448 | 0, 32, 0), MI(i + 448 | 0, 32), Rg(i, Q, 32, 0), Rg(i, g, 32, 0), zg(i, i + 384 | 0, 64), MI(i, 384), A = 0;

                do {
                  B[I + A >> 0] = 0 | B[i + 384 + A >> 0], B[E + A >> 0] = 0 | B[i + 384 + (A + 32) >> 0], A = A + 1 | 0;
                } while (32 != (0 | A));

                MI(i + 384 | 0, 64), A = 0;
              }
              return y = e, 0 | A;
            },
            _crypto_kx_sessionkeybytes: YB,
            _crypto_pwhash: function _crypto_pwhash(A, I, g, B, Q, E, i, e, o, c, a) {
              switch (A |= 0, I |= 0, g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, o |= 0, c |= 0, 0 | (a |= 0)) {
                case 1:
                  I = 0 | function (A, I, g, B, Q, E, i, e, o, c) {
                    g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, o |= 0, c |= 0, YA(0 | (A |= 0), 0, 0 | (I |= 0));

                    do {
                      if (!(g >>> 0 > 0 | 0 == (0 | g) & I >>> 0 > 4294967295)) {
                        if (g >>> 0 < 0 | 0 == (0 | g) & I >>> 0 < 16) {
                          C[8678] = 28, I = -1;
                          break;
                        }

                        if ((o | E) >>> 0 > 0 | 0 == (o | E | 0) & (e | Q) >>> 0 > 4294967295 | c >>> 0 > 2147483648) {
                          C[8678] = 22, I = -1;
                          break;
                        }

                        if (o >>> 0 < 0 | 0 == (0 | o) & e >>> 0 < 3 | c >>> 0 < 8192) {
                          C[8678] = 28, I = -1;
                          break;
                        }

                        I = (0 != (0 | pg(e, c >>> 10, B, Q, i, A, I))) << 31 >> 31;
                        break;
                      }

                      C[8678] = 22, I = -1;
                    } while (0);

                    return 0 | I;
                  }(A, I, g, B, Q, E, i, e, o, c);

                  break;

                case 2:
                  I = 0 | function (A, I, g, B, Q, E, i, e, o, c) {
                    g |= 0, B |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, o |= 0, c |= 0, YA(0 | (A |= 0), 0, 0 | (I |= 0));

                    do {
                      if (!(g >>> 0 > 0 | 0 == (0 | g) & I >>> 0 > 4294967295)) {
                        if (g >>> 0 < 0 | 0 == (0 | g) & I >>> 0 < 16) {
                          C[8678] = 28, I = -1;
                          break;
                        }

                        if ((o | E) >>> 0 > 0 | 0 == (o | E | 0) & (e | Q) >>> 0 > 4294967295 | c >>> 0 > 2147483648) {
                          C[8678] = 22, I = -1;
                          break;
                        }

                        if (0 == (0 | e) & 0 == (0 | o) | c >>> 0 < 8192) {
                          C[8678] = 28, I = -1;
                          break;
                        }

                        I = (0 != (0 | Fg(e, c >>> 10, B, Q, i, A, I))) << 31 >> 31;
                        break;
                      }

                      C[8678] = 22, I = -1;
                    } while (0);

                    return 0 | I;
                  }(A, I, g, B, Q, E, i, e, o, c);

                  break;

                default:
                  C[8678] = 28, I = -1;
              }

              return 0 | I;
            },
            _crypto_pwhash_alg_argon2i13: kB,
            _crypto_pwhash_alg_argon2id13: uB,
            _crypto_pwhash_alg_default: uB,
            _crypto_pwhash_bytes_max: HB,
            _crypto_pwhash_bytes_min: GB,
            _crypto_pwhash_memlimit_interactive: function _crypto_pwhash_memlimit_interactive() {
              return 67108864;
            },
            _crypto_pwhash_memlimit_max: function _crypto_pwhash_memlimit_max() {
              return -2147483648;
            },
            _crypto_pwhash_memlimit_min: function _crypto_pwhash_memlimit_min() {
              return 8192;
            },
            _crypto_pwhash_memlimit_moderate: function _crypto_pwhash_memlimit_moderate() {
              return 268435456;
            },
            _crypto_pwhash_memlimit_sensitive: function _crypto_pwhash_memlimit_sensitive() {
              return 1073741824;
            },
            _crypto_pwhash_opslimit_interactive: uB,
            _crypto_pwhash_opslimit_max: HB,
            _crypto_pwhash_opslimit_min: kB,
            _crypto_pwhash_opslimit_moderate: pB,
            _crypto_pwhash_opslimit_sensitive: function _crypto_pwhash_opslimit_sensitive() {
              return 4;
            },
            _crypto_pwhash_passwd_max: HB,
            _crypto_pwhash_passwd_min: MB,
            _crypto_pwhash_saltbytes: GB,
            _crypto_pwhash_str: function _crypto_pwhash_str(A, I, g, B, C, Q, E) {
              return 0 | LA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0);
            },
            _crypto_pwhash_str_alg: function _crypto_pwhash_str_alg(A, I, g, B, C, Q, E, i) {
              A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0, E |= 0;
              var e = 0;

              switch (0 | (i |= 0)) {
                case 1:
                  e = 0 | RA(A, I, g, B, C, Q, E);
                  break;

                case 2:
                  e = 0 | LA(A, I, g, B, C, Q, E);
                  break;

                default:
                  SB();
              }

              return 0 | e;
            },
            _crypto_pwhash_str_needs_rehash: function _crypto_pwhash_str_needs_rehash(A, I, g, B) {
              A |= 0, I |= 0, g |= 0, B |= 0;

              do {
                if (0 | oI(A, 33713, 10)) {
                  if (0 | oI(A, 33724, 9)) {
                    C[8678] = 28, I = -1;
                    break;
                  }

                  I = 0 | mg(A, I, g, B);
                  break;
                }

                I = 0 | Ng(A, I, g, B);
              } while (0);

              return 0 | I;
            },
            _crypto_pwhash_str_verify: function _crypto_pwhash_str_verify(A, I, g, B) {
              A |= 0, I |= 0, g |= 0, B |= 0;

              do {
                if (0 | oI(A, 33713, 10)) {
                  if (0 | oI(A, 33724, 9)) {
                    C[8678] = 28, g = -1;
                    break;
                  }

                  g = 0 | hI(A, I, g, B);
                  break;
                }

                g = 0 | yI(A, I, g, B);
              } while (0);

              return 0 | g;
            },
            _crypto_pwhash_strbytes: function _crypto_pwhash_strbytes() {
              return 128;
            },
            _crypto_pwhash_strprefix: function _crypto_pwhash_strprefix() {
              return 33713;
            },
            _crypto_scalarmult: BB,
            _crypto_scalarmult_base: eB,
            _crypto_scalarmult_bytes: YB,
            _crypto_scalarmult_scalarbytes: YB,
            _crypto_secretbox_detached: Z,
            _crypto_secretbox_easy: function _crypto_secretbox_easy(A, I, g, B, C, Q) {
              return A |= 0, I |= 0, C |= 0, Q |= 0, (B |= 0) >>> 0 > 0 | 0 == (0 | B) & (g |= 0) >>> 0 > 4294967279 ? (SB(), 0) : (Z(A + 16 | 0, A, I, g, B, C, Q), 0);
            },
            _crypto_secretbox_keybytes: YB,
            _crypto_secretbox_keygen: sB,
            _crypto_secretbox_macbytes: GB,
            _crypto_secretbox_messagebytes_max: FB,
            _crypto_secretbox_noncebytes: _B,
            _crypto_secretbox_open_detached: gA,
            _crypto_secretbox_open_easy: function _crypto_secretbox_open_easy(A, I, g, B, C, Q) {
              return I |= 0, C |= 0, Q |= 0, 0 | ((B |= 0) >>> 0 < 0 | 0 == (0 | B) & (g |= 0) >>> 0 < 16 ? -1 : 0 | gA(A |= 0, I + 16 | 0, I, g = 0 | vg(0 | g, 0 | B, -16, -1), 0 | o(), C, Q));
            },
            _crypto_secretstream_xchacha20poly1305_abytes: function _crypto_secretstream_xchacha20poly1305_abytes() {
              return 17;
            },
            _crypto_secretstream_xchacha20poly1305_headerbytes: _B,
            _crypto_secretstream_xchacha20poly1305_init_pull: function _crypto_secretstream_xchacha20poly1305_init_pull(A, I, g) {
              var C;
              return R(A |= 0, I |= 0, g |= 0), Mg(A), C = Q[I + 16 >> 0] | Q[I + 16 + 1 >> 0] << 8 | Q[I + 16 + 2 >> 0] << 16 | Q[I + 16 + 3 >> 0] << 24, g = Q[I + 16 + 4 >> 0] | Q[I + 16 + 4 + 1 >> 0] << 8 | Q[I + 16 + 4 + 2 >> 0] << 16 | Q[I + 16 + 4 + 3 >> 0] << 24, B[A + 36 >> 0] = C, B[A + 36 + 1 >> 0] = C >> 8, B[A + 36 + 2 >> 0] = C >> 16, B[A + 36 + 3 >> 0] = C >> 24, B[A + 36 + 4 >> 0] = g, B[A + 36 + 4 + 1 >> 0] = g >> 8, B[A + 36 + 4 + 2 >> 0] = g >> 16, B[A + 36 + 4 + 3 >> 0] = g >> 24, B[A + 44 >> 0] = 0, B[A + 44 + 1 >> 0] = 0, B[A + 44 + 2 >> 0] = 0, B[A + 44 + 3 >> 0] = 0, B[A + 44 + 4 >> 0] = 0, B[A + 44 + 4 + 1 >> 0] = 0, B[A + 44 + 4 + 2 >> 0] = 0, B[A + 44 + 4 + 3 >> 0] = 0, 0;
            },
            _crypto_secretstream_xchacha20poly1305_init_push: function _crypto_secretstream_xchacha20poly1305_init_push(A, I, g) {
              return A |= 0, g |= 0, Cg(I |= 0, 24), R(A, I, g), Mg(A), g = Q[I + 16 >> 0] | Q[I + 16 + 1 >> 0] << 8 | Q[I + 16 + 2 >> 0] << 16 | Q[I + 16 + 3 >> 0] << 24, I = Q[I + 16 + 4 >> 0] | Q[I + 16 + 4 + 1 >> 0] << 8 | Q[I + 16 + 4 + 2 >> 0] << 16 | Q[I + 16 + 4 + 3 >> 0] << 24, B[A + 36 >> 0] = g, B[A + 36 + 1 >> 0] = g >> 8, B[A + 36 + 2 >> 0] = g >> 16, B[A + 36 + 3 >> 0] = g >> 24, B[A + 36 + 4 >> 0] = I, B[A + 36 + 4 + 1 >> 0] = I >> 8, B[A + 36 + 4 + 2 >> 0] = I >> 16, B[A + 36 + 4 + 3 >> 0] = I >> 24, B[A + 44 >> 0] = 0, B[A + 44 + 1 >> 0] = 0, B[A + 44 + 2 >> 0] = 0, B[A + 44 + 3 >> 0] = 0, B[A + 44 + 4 >> 0] = 0, B[A + 44 + 4 + 1 >> 0] = 0, B[A + 44 + 4 + 2 >> 0] = 0, B[A + 44 + 4 + 3 >> 0] = 0, 0;
            },
            _crypto_secretstream_xchacha20poly1305_keybytes: YB,
            _crypto_secretstream_xchacha20poly1305_keygen: sB,
            _crypto_secretstream_xchacha20poly1305_messagebytes_max: function _crypto_secretstream_xchacha20poly1305_messagebytes_max() {
              return -18;
            },
            _crypto_secretstream_xchacha20poly1305_pull: function _crypto_secretstream_xchacha20poly1305_pull(A, I, g, Q, E, i, e, c, a, n) {
              A |= 0, I |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0;
              var r,
                  t,
                  f = 0,
                  w = 0,
                  s = 0;
              t = y, r = y = y + 63 & -64, y = y + 352 | 0, 0 | (g |= 0) && (C[g >> 2] = 0, C[g + 4 >> 2] = 0), 0 | Q && (B[Q >> 0] = -1);

              do {
                if (e >>> 0 < 0 | 0 == (0 | e) & i >>> 0 < 17) c = -1;else {
                  w = 0 | vg(0 | i, 0 | e, -17, -1), (s = 0 | o()) >>> 0 > 0 | 0 == (0 | s) & w >>> 0 > 4294967278 && SB(), OI(r + 16 | 0, 64, 0, A + 32 | 0, A), gB(r + 80 | 0, r + 16 | 0), MI(r + 16 | 0, 64), bg(r + 80 | 0, c, a, n), c = 0 | Ug(0, 0, 0 | a, 0 | n), o(), bg(r + 80 | 0, 34672, 15 & c, 0), f = 64 + (c = r + 16 | 0) | 0;

                  do {
                    C[c >> 2] = 0, c = c + 4 | 0;
                  } while ((0 | c) < (0 | f));

                  if (B[r + 16 >> 0] = 0 | B[E >> 0], rI(r + 16 | 0, r + 16 | 0, 64, 0, A + 32 | 0, 1, A), c = 0 | B[r + 16 >> 0], B[r + 16 >> 0] = 0 | B[E >> 0], bg(r + 80 | 0, r + 16 | 0, 64, 0), bg(r + 80 | 0, E + 1 | 0, w, s), f = 0 | vg(0 | i, 0 | e, 15, 0), o(), bg(r + 80 | 0, 34672, 15 & f, 0), LI(r + 336 | 0, a, n), bg(r + 80 | 0, r + 336 | 0, 8, 0), LI(r + 336 | 0, n = 0 | vg(0 | i, 0 | e, 47, 0), 0 | o()), bg(r + 80 | 0, r + 336 | 0, 8, 0), IB(r + 80 | 0, r), MI(r + 80 | 0, 256), 0 | EI(r, E + 1 + w | 0, 16)) {
                    MI(r, 16), c = -1;
                    break;
                  }

                  rI(I, E + 1 | 0, w, s, A + 32 | 0, 2, A), ag(A + 36 | 0, r), Ig(A + 32 | 0), (0 != (2 & c) || 0 | lI(A + 32 | 0, 4)) && wA(A), 0 | g && (C[g >> 2] = w, C[g + 4 >> 2] = s), 0 | Q ? (B[Q >> 0] = c, c = 0) : c = 0;
                }
              } while (0);

              return y = t, 0 | c;
            },
            _crypto_secretstream_xchacha20poly1305_push: function _crypto_secretstream_xchacha20poly1305_push(A, I, g, Q, E, i, e, c, a, n) {
              A |= 0, I |= 0, Q |= 0, E |= 0, i |= 0, e |= 0, c |= 0, a |= 0, n |= 0;
              var r,
                  t,
                  f = 0;
              t = y, f = y = y + 63 & -64, y = y + 336 | 0, 0 | (g |= 0) && (C[g >> 2] = 0, C[g + 4 >> 2] = 0), i >>> 0 > 0 | 0 == (0 | i) & E >>> 0 > 4294967278 && SB(), OI(f, 64, 0, A + 32 | 0, A), gB(f + 64 | 0, f), MI(f, 64), bg(f + 64 | 0, e, c, a), e = 0 | Ug(0, 0, 0 | c, 0 | a), o(), bg(f + 64 | 0, 34672, 15 & e, 0), r = (e = f) + 64 | 0;

              do {
                C[e >> 2] = 0, e = e + 4 | 0;
              } while ((0 | e) < (0 | r));

              return B[f >> 0] = n, rI(f, f, 64, 0, A + 32 | 0, 1, A), bg(f + 64 | 0, f, 64, 0), B[I >> 0] = 0 | B[f >> 0], rI(I + 1 | 0, Q, E, i, A + 32 | 0, 2, A), bg(f + 64 | 0, I + 1 | 0, E, i), bg(f + 64 | 0, 34672, 15 & E, 0), LI(f + 320 | 0, c, a), bg(f + 64 | 0, f + 320 | 0, 8, 0), LI(f + 320 | 0, Q = 0 | vg(0 | E, 0 | i, 64, 0), 0 | o()), bg(f + 64 | 0, f + 320 | 0, 8, 0), IB(f + 64 | 0, I + 1 + E | 0), MI(f + 64 | 0, 256), ag(A + 36 | 0, I + 1 + E | 0), Ig(A + 32 | 0), (0 != (2 & n) || 0 | lI(A + 32 | 0, 4)) && wA(A), 0 | g && (n = 0 | vg(0 | E, 0 | i, 17, 0), f = 0 | o(), C[g >> 2] = n, C[g + 4 >> 2] = f), y = t, 0;
            },
            _crypto_secretstream_xchacha20poly1305_rekey: wA,
            _crypto_secretstream_xchacha20poly1305_statebytes: function _crypto_secretstream_xchacha20poly1305_statebytes() {
              return 52;
            },
            _crypto_secretstream_xchacha20poly1305_tag_final: pB,
            _crypto_secretstream_xchacha20poly1305_tag_message: MB,
            _crypto_secretstream_xchacha20poly1305_tag_push: kB,
            _crypto_secretstream_xchacha20poly1305_tag_rekey: uB,
            _crypto_shorthash: function _crypto_shorthash(A, I, g, B, C) {
              return G(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0), 0;
            },
            _crypto_shorthash_bytes: lB,
            _crypto_shorthash_keybytes: GB,
            _crypto_shorthash_keygen: function _crypto_shorthash_keygen(A) {
              Cg(A |= 0, 16);
            },
            _crypto_sign: function _crypto_sign(A, I, g, B, C, Q) {
              return 0 | TA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0);
            },
            _crypto_sign_bytes: dB,
            _crypto_sign_detached: function _crypto_sign_detached(A, I, g, B, C, Q) {
              return kg(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0), 0;
            },
            _crypto_sign_ed25519_pk_to_curve25519: function _crypto_sign_ed25519_pk_to_curve25519(A, I) {
              var g, B;
              return A |= 0, B = y, g = y = y + 63 & -64, y = y + 256 | 0, 0 == (0 | GA(I |= 0)) && 0 == (0 | rA(g + 88 | 0, I)) && 0 != (0 | function (A) {
                var I, g;
                return I = y, g = y = y + 63 & -64, y = y + 160 | 0, O(g, A |= 0), A = 0 | cg(g), y = I, 0 | A;
              }(g + 88 | 0)) ? (Sg(g), lA(g, g, g + 88 + 40 | 0), Sg(g + 48 | 0), _A(g + 48 | 0, g + 48 | 0, g + 88 + 40 | 0), W(g, g), u(g + 48 | 0, g + 48 | 0, g), CA(A, g + 48 | 0), A = 0) : A = -1, y = B, 0 | A;
            },
            _crypto_sign_ed25519_sk_to_curve25519: function _crypto_sign_ed25519_sk_to_curve25519(A, I) {
              var g, C, Q;
              A |= 0, C = y, Q = y = y + 63 & -64, y = y + 64 | 0, RI(Q, I |= 0, 32, 0), B[Q >> 0] = -8 & B[Q >> 0], B[Q + 31 >> 0] = 63 & B[Q + 31 >> 0] | 64, I = Q, g = A + 32 | 0;

              do {
                B[A >> 0] = 0 | B[I >> 0], A = A + 1 | 0, I = I + 1 | 0;
              } while ((0 | A) < (0 | g));

              return MI(Q, 64), y = C, 0;
            },
            _crypto_sign_final_create: function _crypto_sign_final_create(A, I, g, B) {
              return function (A, I, g, B) {
                var C, Q;
                I |= 0, g |= 0, B |= 0, C = y, Q = y = y + 63 & -64, y = y + 64 | 0, VI(A |= 0, Q), hA(I, g, Q, 64, 0, B, 1), y = C;
              }(A |= 0, I |= 0, g |= 0, B |= 0), 0;
            },
            _crypto_sign_final_verify: function _crypto_sign_final_verify(A, I, g) {
              return 0 | function (A, I, g) {
                var B, C;
                return I |= 0, g |= 0, B = y, C = y = y + 63 & -64, y = y + 64 | 0, VI(A |= 0, C), A = 0 | uA(I, C, 64, 0, g, 1), y = B, 0 | A;
              }(A |= 0, I |= 0, g |= 0);
            },
            _crypto_sign_init: function _crypto_sign_init(A) {
              return function (A) {
                PI(A |= 0);
              }(A |= 0), 0;
            },
            _crypto_sign_keypair: function _crypto_sign_keypair(A, I) {
              return function (A, I) {
                var g, B;
                A |= 0, I |= 0, g = y, B = y = y + 63 & -64, y = y + 32 | 0, Cg(B, 32), wI(A, I, B), MI(B, 32), y = g;
              }(A |= 0, I |= 0), 0;
            },
            _crypto_sign_messagebytes_max: function _crypto_sign_messagebytes_max() {
              return -65;
            },
            _crypto_sign_open: function _crypto_sign_open(A, I, g, B, C, Q) {
              return 0 | SA(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0, Q |= 0);
            },
            _crypto_sign_publickeybytes: YB,
            _crypto_sign_secretkeybytes: dB,
            _crypto_sign_seed_keypair: function _crypto_sign_seed_keypair(A, I, g) {
              return wI(A |= 0, I |= 0, g |= 0), 0;
            },
            _crypto_sign_seedbytes: YB,
            _crypto_sign_statebytes: function _crypto_sign_statebytes() {
              return 208;
            },
            _crypto_sign_update: function _crypto_sign_update(A, I, g, B) {
              return xg(A |= 0, I |= 0, g |= 0, B |= 0), 0;
            },
            _crypto_sign_verify_detached: function _crypto_sign_verify_detached(A, I, g, B, C) {
              return 0 | dg(A |= 0, I |= 0, g |= 0, B |= 0, C |= 0);
            },
            _emscripten_get_sbrk_ptr: function _emscripten_get_sbrk_ptr() {
              return 35232;
            },
            _emscripten_replace_memory: function _emscripten_replace_memory(A) {
              return B = new Int8Array(A), Q = new Uint8Array(A), C = new Int32Array(A), g = A, !0;
            },
            _free: d,
            _i64Add: vg,
            _i64Subtract: Ug,
            _malloc: F,
            _memcpy: BA,
            _memmove: YI,
            _memset: YA,
            _randombytes: function _randombytes(A, I, g) {
              (g |= 0) >>> 0 < 1 | 1 == (0 | g) & (I |= 0) >>> 0 < 0 ? Cg(A |= 0, I) : c(34506, 34526, 197, 34552);
            },
            _randombytes_buf: Cg,
            _randombytes_buf_deterministic: function _randombytes_buf_deterministic(A, I, g) {
              OI(A |= 0, I |= 0, 0, 34494, g |= 0);
            },
            _randombytes_close: MB,
            _randombytes_random: DB,
            _randombytes_seedbytes: YB,
            _randombytes_stir: hB,
            _randombytes_uniform: function _randombytes_uniform(A) {
              var I = 0;
              if ((A |= 0) >>> 0 < 2) I = 0;else {
                do {
                  I = 0 | DB();
                } while (I >>> 0 < (((0 - A | 0) >>> 0) % (A >>> 0) | 0) >>> 0);

                I = (I >>> 0) % (A >>> 0) | 0;
              }
              return 0 | I;
            },
            _sodium_base642bin: m,
            _sodium_base64_encoded_len: function _sodium_base64_encoded_len(A, I) {
              var g;
              return A |= 0, EB(I |= 0), (((A >>> 0) / 3 | 0) << 2 | 1) + (4 - (3 - (g = (0 | E((A >>> 0) / 3 | 0, -3)) + A | 0) & 0 - (I >>> 1 & 1)) & 0 - (1 & (g >>> 1 | g))) | 0;
            },
            _sodium_bin2base64: q,
            _sodium_bin2hex: function _sodium_bin2hex(A, I, g, C) {
              A |= 0, g |= 0;
              var E = 0,
                  i = 0;

              if ((C |= 0) >>> 0 < 2147483647 & C << 1 >>> 0 < (I |= 0) >>> 0 || SB(), C) {
                I = 0;

                do {
                  i = 0 | Q[g + I >> 0], B[A + (E = I << 1) >> 0] = 87 + (i >>> 4) + ((65526 + (i >>> 4) | 0) >>> 8 & 217), B[A + (1 | E) >> 0] = (22272 + ((15 & i) << 8) + (65526 + (15 & i) & 55552) | 0) >>> 8, I = I + 1 | 0;
                } while ((0 | I) != (0 | C));

                I = C << 1;
              } else I = 0;

              return B[A + I >> 0] = 0, 0 | A;
            },
            _sodium_hex2bin: function _sodium_hex2bin(A, I, g, E, i, e, o) {
              A |= 0, I |= 0, g |= 0, E |= 0, i |= 0, e |= 0, o |= 0;
              var c = 0,
                  a = 0,
                  n = 0,
                  r = 0,
                  t = 0,
                  f = 0,
                  w = 0;

              A: do {
                if (E) {
                  r = 0, f = 0, c = 0, a = 0;

                  I: for (;;) {
                    for (; !(255 & ((t = (65526 + (201 + (223 & (n = 0 | Q[g + c >> 0])) & 255) ^ 65520 + (201 + (223 & n) & 255)) >>> 8) | (65526 + (48 ^ n) | 0) >>> 8) | 0);) {
                      if (!(0 != (0 | i) & a << 24 >> 24 == 0)) {
                        n = 0;
                        break I;
                      }

                      if (!(0 | qg(i, n))) {
                        a = r, w = 17;
                        break A;
                      }

                      if (!((c = c + 1 | 0) >>> 0 < E >>> 0)) {
                        a = r, w = 17;
                        break A;
                      }

                      a = 0;
                    }

                    if (n = t & 201 + (223 & n) | (65526 + (48 ^ n) | 0) >>> 8 & (48 ^ n), r >>> 0 >= I >>> 0) {
                      w = 9;
                      break;
                    }

                    if (a << 24 >> 24 ? (B[A + r >> 0] = n | 255 & f, r = r + 1 | 0, n = f) : n = n << 4 & 255, a = ~a, !((c = c + 1 | 0) >>> 0 < E >>> 0)) {
                      n = 0;
                      break;
                    }

                    f = n;
                  }

                  if (9 == (0 | w) && (C[8678] = 68, n = -1), a << 24 >> 24) {
                    C[8678] = 28, n = 0, a = c + -1 | 0, c = -1;
                    break;
                  }

                  if (n) {
                    n = 0, a = c, c = -1;
                    break;
                  }

                  a = r, w = 17;
                  break;
                }

                a = 0, c = 0, w = 17;
              } while (0);

              return 17 == (0 | w) && (n = a, a = c, c = 0), o ? C[o >> 2] = g + a : (0 | a) != (0 | E) && (C[8678] = 28, c = -1), 0 | e && (C[e >> 2] = n), 0 | c;
            },
            _sodium_init: function _sodium_init() {
              var A = 0;
              return 0 | C[8676] ? A = 1 : (function () {
                return A = y, I = y = y + 63 & -64, y = y + 16 | 0, Zg(I), 0 | C[I >> 2] && Zg(I), void (y = A);
                var A, I;
              }(), hB(), function () {
                var A = 0;
                (0 | (A = 0 | w(30))) > 0 ? C[8677] = A : A = 0 | C[8677], A >>> 0 < 16 ? SB() : Cg(34688, 16);
              }(), C[8676] = 1, A = 0), 0 | A;
            },
            _sodium_library_minimal: kB,
            _sodium_library_version_major: function _sodium_library_version_major() {
              return 10;
            },
            _sodium_library_version_minor: pB,
            _sodium_pad: function _sodium_pad(A, I, g, E, i) {
              A |= 0, I |= 0, g |= 0, i |= 0;
              var e,
                  o,
                  c = 0,
                  a = 0;
              if (o = y, e = y = y + 63 & -64, y = y + 16 | 0, E |= 0) {
                if ((a = E + -1 - (c = E + -1 & E ? (g >>> 0) % (E >>> 0) | 0 : E + -1 & g) | 0) >>> 0 >= ~g >>> 0 && SB(), (a + g | 0) >>> 0 < i >>> 0) {
                  0 | A && (C[A >> 2] = a + g + 1), B[e >> 0] = 0, c = 0;

                  do {
                    A = ((c ^ a) - 1 | 0) >>> 24, B[(i = I + (a + g) + (0 - c) | 0) >> 0] = 128 & A | B[e >> 0] & B[i >> 0] & 255, B[e >> 0] = 0 | A | Q[e >> 0], c = c + 1 | 0;
                  } while ((0 | c) != (0 | E));

                  c = 0;
                } else c = -1;
              } else c = -1;
              return y = o, 0 | c;
            },
            _sodium_unpad: function _sodium_unpad(A, I, g, B) {
              A |= 0, I |= 0, g |= 0, B |= 0;
              var E,
                  i,
                  e = 0,
                  o = 0,
                  c = 0,
                  a = 0,
                  n = 0;

              if (i = y, E = y = y + 63 & -64, y = y + 16 | 0, C[E >> 2] = 0, (B + -1 | 0) >>> 0 < g >>> 0) {
                for (e = 0, c = 0, a = 0; e &= 255, o = 0 | Q[I + (g + -1) + (0 - c) >> 0], n = (511 + (0 | C[E >> 2]) & e + 511 & 511 + (128 ^ o)) >>> 8 & 1, C[E >> 2] = c & 0 - n | C[E >> 2], a = n | 255 & a, (0 | (c = c + 1 | 0)) != (0 | B);) {
                  e |= o;
                }

                C[A >> 2] = g + -1 - (0 | C[E >> 2]), e = a + -1 | 0;
              } else e = -1;

              return y = i, 0 | e;
            },
            _sodium_version_string: function _sodium_version_string() {
              return 34617;
            },
            establishStackSpace: function establishStackSpace(A, I) {
              y = A |= 0;
            },
            stackAlloc: function stackAlloc(A) {
              var I;
              return I = y, y = 15 + (y = y + (A |= 0) | 0) & -16, 0 | I;
            },
            stackRestore: function stackRestore(A) {
              y = A |= 0;
            },
            stackSave: function stackSave() {
              return 0 | y;
            }
          };
        }({
          Math: Math,
          Int8Array: Int8Array,
          Int32Array: Int32Array,
          Uint8Array: Uint8Array
        }, {
          a: j,
          b: function b(A) {
            s = A;
          },
          c: function c() {
            return s;
          },
          d: function d(A, I, g, B) {
            j("Assertion failed: " + _d(A) + ", at: " + [I ? _d(I) : "unknown filename", g, B ? _d(B) : "unknown function"]);
          },
          e: BA,
          f: function f() {
            j();
          },
          g: function g(A) {
            return O[A]();
          },
          h: IA,
          i: function i(A, I, g) {
            u.set(u.subarray(I, I + g), A);
          },
          j: function j(A) {
            var I = IA();
            if (A > 2130706432) return !1;

            for (var g = Math.max(I, 16777216); g < A;) {
              g = g <= 536870912 ? Y(2 * g, 16777216) : Math.min(Y((3 * g + 2147483648) / 4, 16777216), 2130706432);
            }

            return !!gA(g);
          },
          k: function k(A) {
            switch (A) {
              case 30:
                return 16384;

              case 85:
                return 130048;

              case 132:
              case 133:
              case 12:
              case 137:
              case 138:
              case 15:
              case 235:
              case 16:
              case 17:
              case 18:
              case 19:
              case 20:
              case 149:
              case 13:
              case 10:
              case 236:
              case 153:
              case 9:
              case 21:
              case 22:
              case 159:
              case 154:
              case 14:
              case 77:
              case 78:
              case 139:
              case 80:
              case 81:
              case 82:
              case 68:
              case 67:
              case 164:
              case 11:
              case 29:
              case 47:
              case 48:
              case 95:
              case 52:
              case 51:
              case 46:
                return 200809;

              case 79:
                return 0;

              case 27:
              case 246:
              case 127:
              case 128:
              case 23:
              case 24:
              case 160:
              case 161:
              case 181:
              case 182:
              case 242:
              case 183:
              case 184:
              case 243:
              case 244:
              case 245:
              case 165:
              case 178:
              case 179:
              case 49:
              case 50:
              case 168:
              case 169:
              case 175:
              case 170:
              case 171:
              case 172:
              case 97:
              case 76:
              case 32:
              case 173:
              case 35:
                return -1;

              case 176:
              case 177:
              case 7:
              case 155:
              case 8:
              case 157:
              case 125:
              case 126:
              case 92:
              case 93:
              case 129:
              case 130:
              case 131:
              case 94:
              case 91:
                return 1;

              case 74:
              case 60:
              case 69:
              case 70:
              case 4:
                return 1024;

              case 31:
              case 42:
              case 72:
                return 32;

              case 87:
              case 26:
              case 33:
                return 2147483647;

              case 34:
              case 1:
                return 47839;

              case 38:
              case 36:
                return 99;

              case 43:
              case 37:
                return 2048;

              case 0:
                return 2097152;

              case 3:
                return 65536;

              case 28:
                return 32768;

              case 44:
                return 32767;

              case 75:
                return 16384;

              case 39:
                return 1e3;

              case 89:
                return 700;

              case 71:
                return 256;

              case 40:
                return 255;

              case 2:
                return 100;

              case 180:
                return 64;

              case 25:
                return 20;

              case 5:
                return 16;

              case 6:
                return 6;

              case 73:
                return 4;

              case 84:
                return "object" == (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) && navigator.hardwareConcurrency || 1;
            }

            return BA(28), -1;
          },
          l: function l(A) {
            j("OOM");
          },
          m: Z,
          n: $,
          o: gA,
          p: AA,
          q: function q() {
            var A = AA();
            return I.extraStackTrace && (A += "\n" + I.extraStackTrace()), $(A);
          },
          r: 35408
        }, F),
            aA = (I.___errno_location = cA.___errno_location, I.___muldi3 = cA.___muldi3, I.___uremdi3 = cA.___uremdi3, I._bitshift64Ashr = cA._bitshift64Ashr, I._bitshift64Lshr = cA._bitshift64Lshr, I._bitshift64Shl = cA._bitshift64Shl, I._crypto_aead_chacha20poly1305_abytes = cA._crypto_aead_chacha20poly1305_abytes, I._crypto_aead_chacha20poly1305_decrypt = cA._crypto_aead_chacha20poly1305_decrypt, I._crypto_aead_chacha20poly1305_decrypt_detached = cA._crypto_aead_chacha20poly1305_decrypt_detached, I._crypto_aead_chacha20poly1305_encrypt = cA._crypto_aead_chacha20poly1305_encrypt, I._crypto_aead_chacha20poly1305_encrypt_detached = cA._crypto_aead_chacha20poly1305_encrypt_detached, I._crypto_aead_chacha20poly1305_ietf_abytes = cA._crypto_aead_chacha20poly1305_ietf_abytes, I._crypto_aead_chacha20poly1305_ietf_decrypt = cA._crypto_aead_chacha20poly1305_ietf_decrypt, I._crypto_aead_chacha20poly1305_ietf_decrypt_detached = cA._crypto_aead_chacha20poly1305_ietf_decrypt_detached, I._crypto_aead_chacha20poly1305_ietf_encrypt = cA._crypto_aead_chacha20poly1305_ietf_encrypt, I._crypto_aead_chacha20poly1305_ietf_encrypt_detached = cA._crypto_aead_chacha20poly1305_ietf_encrypt_detached, I._crypto_aead_chacha20poly1305_ietf_keybytes = cA._crypto_aead_chacha20poly1305_ietf_keybytes, I._crypto_aead_chacha20poly1305_ietf_keygen = cA._crypto_aead_chacha20poly1305_ietf_keygen, I._crypto_aead_chacha20poly1305_ietf_messagebytes_max = cA._crypto_aead_chacha20poly1305_ietf_messagebytes_max, I._crypto_aead_chacha20poly1305_ietf_npubbytes = cA._crypto_aead_chacha20poly1305_ietf_npubbytes, I._crypto_aead_chacha20poly1305_ietf_nsecbytes = cA._crypto_aead_chacha20poly1305_ietf_nsecbytes, I._crypto_aead_chacha20poly1305_keybytes = cA._crypto_aead_chacha20poly1305_keybytes, I._crypto_aead_chacha20poly1305_keygen = cA._crypto_aead_chacha20poly1305_keygen, I._crypto_aead_chacha20poly1305_messagebytes_max = cA._crypto_aead_chacha20poly1305_messagebytes_max, I._crypto_aead_chacha20poly1305_npubbytes = cA._crypto_aead_chacha20poly1305_npubbytes, I._crypto_aead_chacha20poly1305_nsecbytes = cA._crypto_aead_chacha20poly1305_nsecbytes, I._crypto_aead_xchacha20poly1305_ietf_abytes = cA._crypto_aead_xchacha20poly1305_ietf_abytes, I._crypto_aead_xchacha20poly1305_ietf_decrypt = cA._crypto_aead_xchacha20poly1305_ietf_decrypt, I._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = cA._crypto_aead_xchacha20poly1305_ietf_decrypt_detached, I._crypto_aead_xchacha20poly1305_ietf_encrypt = cA._crypto_aead_xchacha20poly1305_ietf_encrypt, I._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = cA._crypto_aead_xchacha20poly1305_ietf_encrypt_detached, I._crypto_aead_xchacha20poly1305_ietf_keybytes = cA._crypto_aead_xchacha20poly1305_ietf_keybytes, I._crypto_aead_xchacha20poly1305_ietf_keygen = cA._crypto_aead_xchacha20poly1305_ietf_keygen, I._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = cA._crypto_aead_xchacha20poly1305_ietf_messagebytes_max, I._crypto_aead_xchacha20poly1305_ietf_npubbytes = cA._crypto_aead_xchacha20poly1305_ietf_npubbytes, I._crypto_aead_xchacha20poly1305_ietf_nsecbytes = cA._crypto_aead_xchacha20poly1305_ietf_nsecbytes, I._crypto_auth = cA._crypto_auth, I._crypto_auth_bytes = cA._crypto_auth_bytes, I._crypto_auth_keybytes = cA._crypto_auth_keybytes, I._crypto_auth_keygen = cA._crypto_auth_keygen, I._crypto_auth_verify = cA._crypto_auth_verify, I._crypto_box_beforenm = cA._crypto_box_beforenm, I._crypto_box_beforenmbytes = cA._crypto_box_beforenmbytes, I._crypto_box_detached = cA._crypto_box_detached, I._crypto_box_detached_afternm = cA._crypto_box_detached_afternm, I._crypto_box_easy = cA._crypto_box_easy, I._crypto_box_easy_afternm = cA._crypto_box_easy_afternm, I._crypto_box_keypair = cA._crypto_box_keypair, I._crypto_box_macbytes = cA._crypto_box_macbytes, I._crypto_box_messagebytes_max = cA._crypto_box_messagebytes_max, I._crypto_box_noncebytes = cA._crypto_box_noncebytes, I._crypto_box_open_detached = cA._crypto_box_open_detached, I._crypto_box_open_detached_afternm = cA._crypto_box_open_detached_afternm, I._crypto_box_open_easy = cA._crypto_box_open_easy, I._crypto_box_open_easy_afternm = cA._crypto_box_open_easy_afternm, I._crypto_box_publickeybytes = cA._crypto_box_publickeybytes, I._crypto_box_seal = cA._crypto_box_seal, I._crypto_box_seal_open = cA._crypto_box_seal_open, I._crypto_box_sealbytes = cA._crypto_box_sealbytes, I._crypto_box_secretkeybytes = cA._crypto_box_secretkeybytes, I._crypto_box_seed_keypair = cA._crypto_box_seed_keypair, I._crypto_box_seedbytes = cA._crypto_box_seedbytes, I._crypto_generichash = cA._crypto_generichash, I._crypto_generichash_bytes = cA._crypto_generichash_bytes, I._crypto_generichash_bytes_max = cA._crypto_generichash_bytes_max, I._crypto_generichash_bytes_min = cA._crypto_generichash_bytes_min, I._crypto_generichash_final = cA._crypto_generichash_final, I._crypto_generichash_init = cA._crypto_generichash_init, I._crypto_generichash_keybytes = cA._crypto_generichash_keybytes, I._crypto_generichash_keybytes_max = cA._crypto_generichash_keybytes_max, I._crypto_generichash_keybytes_min = cA._crypto_generichash_keybytes_min, I._crypto_generichash_keygen = cA._crypto_generichash_keygen, I._crypto_generichash_statebytes = cA._crypto_generichash_statebytes, I._crypto_generichash_update = cA._crypto_generichash_update, I._crypto_hash = cA._crypto_hash, I._crypto_hash_bytes = cA._crypto_hash_bytes, I._crypto_kdf_bytes_max = cA._crypto_kdf_bytes_max, I._crypto_kdf_bytes_min = cA._crypto_kdf_bytes_min, I._crypto_kdf_contextbytes = cA._crypto_kdf_contextbytes, I._crypto_kdf_derive_from_key = cA._crypto_kdf_derive_from_key, I._crypto_kdf_keybytes = cA._crypto_kdf_keybytes, I._crypto_kdf_keygen = cA._crypto_kdf_keygen, I._crypto_kx_client_session_keys = cA._crypto_kx_client_session_keys, I._crypto_kx_keypair = cA._crypto_kx_keypair, I._crypto_kx_publickeybytes = cA._crypto_kx_publickeybytes, I._crypto_kx_secretkeybytes = cA._crypto_kx_secretkeybytes, I._crypto_kx_seed_keypair = cA._crypto_kx_seed_keypair, I._crypto_kx_seedbytes = cA._crypto_kx_seedbytes, I._crypto_kx_server_session_keys = cA._crypto_kx_server_session_keys, I._crypto_kx_sessionkeybytes = cA._crypto_kx_sessionkeybytes, I._crypto_pwhash = cA._crypto_pwhash, I._crypto_pwhash_alg_argon2i13 = cA._crypto_pwhash_alg_argon2i13, I._crypto_pwhash_alg_argon2id13 = cA._crypto_pwhash_alg_argon2id13, I._crypto_pwhash_alg_default = cA._crypto_pwhash_alg_default, I._crypto_pwhash_bytes_max = cA._crypto_pwhash_bytes_max, I._crypto_pwhash_bytes_min = cA._crypto_pwhash_bytes_min, I._crypto_pwhash_memlimit_interactive = cA._crypto_pwhash_memlimit_interactive, I._crypto_pwhash_memlimit_max = cA._crypto_pwhash_memlimit_max, I._crypto_pwhash_memlimit_min = cA._crypto_pwhash_memlimit_min, I._crypto_pwhash_memlimit_moderate = cA._crypto_pwhash_memlimit_moderate, I._crypto_pwhash_memlimit_sensitive = cA._crypto_pwhash_memlimit_sensitive, I._crypto_pwhash_opslimit_interactive = cA._crypto_pwhash_opslimit_interactive, I._crypto_pwhash_opslimit_max = cA._crypto_pwhash_opslimit_max, I._crypto_pwhash_opslimit_min = cA._crypto_pwhash_opslimit_min, I._crypto_pwhash_opslimit_moderate = cA._crypto_pwhash_opslimit_moderate, I._crypto_pwhash_opslimit_sensitive = cA._crypto_pwhash_opslimit_sensitive, I._crypto_pwhash_passwd_max = cA._crypto_pwhash_passwd_max, I._crypto_pwhash_passwd_min = cA._crypto_pwhash_passwd_min, I._crypto_pwhash_saltbytes = cA._crypto_pwhash_saltbytes, I._crypto_pwhash_str = cA._crypto_pwhash_str, I._crypto_pwhash_str_alg = cA._crypto_pwhash_str_alg, I._crypto_pwhash_str_needs_rehash = cA._crypto_pwhash_str_needs_rehash, I._crypto_pwhash_str_verify = cA._crypto_pwhash_str_verify, I._crypto_pwhash_strbytes = cA._crypto_pwhash_strbytes, I._crypto_pwhash_strprefix = cA._crypto_pwhash_strprefix, I._crypto_scalarmult = cA._crypto_scalarmult, I._crypto_scalarmult_base = cA._crypto_scalarmult_base, I._crypto_scalarmult_bytes = cA._crypto_scalarmult_bytes, I._crypto_scalarmult_scalarbytes = cA._crypto_scalarmult_scalarbytes, I._crypto_secretbox_detached = cA._crypto_secretbox_detached, I._crypto_secretbox_easy = cA._crypto_secretbox_easy, I._crypto_secretbox_keybytes = cA._crypto_secretbox_keybytes, I._crypto_secretbox_keygen = cA._crypto_secretbox_keygen, I._crypto_secretbox_macbytes = cA._crypto_secretbox_macbytes, I._crypto_secretbox_messagebytes_max = cA._crypto_secretbox_messagebytes_max, I._crypto_secretbox_noncebytes = cA._crypto_secretbox_noncebytes, I._crypto_secretbox_open_detached = cA._crypto_secretbox_open_detached, I._crypto_secretbox_open_easy = cA._crypto_secretbox_open_easy, I._crypto_secretstream_xchacha20poly1305_abytes = cA._crypto_secretstream_xchacha20poly1305_abytes, I._crypto_secretstream_xchacha20poly1305_headerbytes = cA._crypto_secretstream_xchacha20poly1305_headerbytes, I._crypto_secretstream_xchacha20poly1305_init_pull = cA._crypto_secretstream_xchacha20poly1305_init_pull, I._crypto_secretstream_xchacha20poly1305_init_push = cA._crypto_secretstream_xchacha20poly1305_init_push, I._crypto_secretstream_xchacha20poly1305_keybytes = cA._crypto_secretstream_xchacha20poly1305_keybytes, I._crypto_secretstream_xchacha20poly1305_keygen = cA._crypto_secretstream_xchacha20poly1305_keygen, I._crypto_secretstream_xchacha20poly1305_messagebytes_max = cA._crypto_secretstream_xchacha20poly1305_messagebytes_max, I._crypto_secretstream_xchacha20poly1305_pull = cA._crypto_secretstream_xchacha20poly1305_pull, I._crypto_secretstream_xchacha20poly1305_push = cA._crypto_secretstream_xchacha20poly1305_push, I._crypto_secretstream_xchacha20poly1305_rekey = cA._crypto_secretstream_xchacha20poly1305_rekey, I._crypto_secretstream_xchacha20poly1305_statebytes = cA._crypto_secretstream_xchacha20poly1305_statebytes, I._crypto_secretstream_xchacha20poly1305_tag_final = cA._crypto_secretstream_xchacha20poly1305_tag_final, I._crypto_secretstream_xchacha20poly1305_tag_message = cA._crypto_secretstream_xchacha20poly1305_tag_message, I._crypto_secretstream_xchacha20poly1305_tag_push = cA._crypto_secretstream_xchacha20poly1305_tag_push, I._crypto_secretstream_xchacha20poly1305_tag_rekey = cA._crypto_secretstream_xchacha20poly1305_tag_rekey, I._crypto_shorthash = cA._crypto_shorthash, I._crypto_shorthash_bytes = cA._crypto_shorthash_bytes, I._crypto_shorthash_keybytes = cA._crypto_shorthash_keybytes, I._crypto_shorthash_keygen = cA._crypto_shorthash_keygen, I._crypto_sign = cA._crypto_sign, I._crypto_sign_bytes = cA._crypto_sign_bytes, I._crypto_sign_detached = cA._crypto_sign_detached, I._crypto_sign_ed25519_pk_to_curve25519 = cA._crypto_sign_ed25519_pk_to_curve25519, I._crypto_sign_ed25519_sk_to_curve25519 = cA._crypto_sign_ed25519_sk_to_curve25519, I._crypto_sign_final_create = cA._crypto_sign_final_create, I._crypto_sign_final_verify = cA._crypto_sign_final_verify, I._crypto_sign_init = cA._crypto_sign_init, I._crypto_sign_keypair = cA._crypto_sign_keypair, I._crypto_sign_messagebytes_max = cA._crypto_sign_messagebytes_max, I._crypto_sign_open = cA._crypto_sign_open, I._crypto_sign_publickeybytes = cA._crypto_sign_publickeybytes, I._crypto_sign_secretkeybytes = cA._crypto_sign_secretkeybytes, I._crypto_sign_seed_keypair = cA._crypto_sign_seed_keypair, I._crypto_sign_seedbytes = cA._crypto_sign_seedbytes, I._crypto_sign_statebytes = cA._crypto_sign_statebytes, I._crypto_sign_update = cA._crypto_sign_update, I._crypto_sign_verify_detached = cA._crypto_sign_verify_detached, I._emscripten_get_sbrk_ptr = cA._emscripten_get_sbrk_ptr, I._emscripten_replace_memory = cA._emscripten_replace_memory);

        if (I._free = cA._free, I._i64Add = cA._i64Add, I._i64Subtract = cA._i64Subtract, I._malloc = cA._malloc, I._memcpy = cA._memcpy, I._memmove = cA._memmove, I._memset = cA._memset, I._randombytes = cA._randombytes, I._randombytes_buf = cA._randombytes_buf, I._randombytes_buf_deterministic = cA._randombytes_buf_deterministic, I._randombytes_close = cA._randombytes_close, I._randombytes_random = cA._randombytes_random, I._randombytes_seedbytes = cA._randombytes_seedbytes, I._randombytes_stir = cA._randombytes_stir, I._randombytes_uniform = cA._randombytes_uniform, I._sodium_base642bin = cA._sodium_base642bin, I._sodium_base64_encoded_len = cA._sodium_base64_encoded_len, I._sodium_bin2base64 = cA._sodium_bin2base64, I._sodium_bin2hex = cA._sodium_bin2hex, I._sodium_hex2bin = cA._sodium_hex2bin, I._sodium_init = cA._sodium_init, I._sodium_library_minimal = cA._sodium_library_minimal, I._sodium_library_version_major = cA._sodium_library_version_major, I._sodium_library_version_minor = cA._sodium_library_version_minor, I._sodium_pad = cA._sodium_pad, I._sodium_unpad = cA._sodium_unpad, I._sodium_version_string = cA._sodium_version_string, I.establishStackSpace = cA.establishStackSpace, I.stackAlloc = cA.stackAlloc, I.stackRestore = cA.stackRestore, I.stackSave = cA.stackSave, I.asm = cA, I.setValue = function (A, I, g, B) {
          switch ("*" === (g = g || "i8").charAt(g.length - 1) && (g = "i32"), g) {
            case "i1":
            case "i8":
              p[A >> 0] = I;
              break;

            case "i16":
              H[A >> 1] = I;
              break;

            case "i32":
              k[A >> 2] = I;
              break;

            case "i64":
              q = [I >>> 0, (T = I, +R(T) >= 1 ? T > 0 ? (0 | L(+m(T / 4294967296), 4294967295)) >>> 0 : ~~+N((T - +(~~T >>> 0)) / 4294967296) >>> 0 : 0)], k[A >> 2] = q[0], k[A + 4 >> 2] = q[1];
              break;

            case "float":
              l[A >> 2] = I;
              break;

            case "double":
              _[A >> 3] = I;
              break;

            default:
              j("invalid type for setValue: " + g);
          }
        }, I.getValue = function (A, I, g) {
          switch ("*" === (I = I || "i8").charAt(I.length - 1) && (I = "i32"), I) {
            case "i1":
            case "i8":
              return p[A >> 0];

            case "i16":
              return H[A >> 1];

            case "i32":
            case "i64":
              return k[A >> 2];

            case "float":
              return l[A >> 2];

            case "double":
              return _[A >> 3];

            default:
              j("invalid type for getValue: " + I);
          }

          return null;
        }, I.UTF8ToString = _d, V) if (W(V) || (eA = V, V = I.locateFile ? I.locateFile(eA, f) : f + eA), o || i) {
          var nA = n(V);
          u.set(nA, 8);
        } else {
          x++, I.monitorRunDependencies && I.monitorRunDependencies(x);

          var rA = function rA(A) {
            A.byteLength && (A = new Uint8Array(A)), u.set(A, 8), I.memoryInitializerRequest && delete I.memoryInitializerRequest.response, function (A) {
              if (x--, I.monitorRunDependencies && I.monitorRunDependencies(x), 0 == x && (null !== K && (clearInterval(K), K = null), X)) {
                var g = X;
                X = null, g();
              }
            }();
          },
              tA = function tA() {
            a(V, rA, function () {
              throw "could not load memory initializer " + V;
            });
          },
              fA = iA(V);

          if (fA) rA(fA.buffer);else if (I.memoryInitializerRequest) {
            var wA = function wA() {
              var A = I.memoryInitializerRequest,
                  g = A.response;

              if (200 !== A.status && 0 !== A.status) {
                var B = iA(I.memoryInitializerRequestURL);
                if (!B) return void tA();
                g = B.buffer;
              }

              rA(g);
            };

            I.memoryInitializerRequest.response ? setTimeout(wA, 0) : I.memoryInitializerRequest.addEventListener("load", wA);
          } else tA();
        }

        function yA(A) {
          function g() {
            oA || (oA = !0, h || (U(b), U(J), I.onRuntimeInitialized && I.onRuntimeInitialized(), function () {
              if (I.postRun) for ("function" == typeof I.postRun && (I.postRun = [I.postRun]); I.postRun.length;) {
                A = I.postRun.shift(), P.unshift(A);
              }
              var A;
              U(P);
            }()));
          }

          A = A || e, x > 0 || (function () {
            if (I.preRun) for ("function" == typeof I.preRun && (I.preRun = [I.preRun]); I.preRun.length;) {
              A = I.preRun.shift(), v.unshift(A);
            }
            var A;
            U(v);
          }(), x > 0 || (I.setStatus ? (I.setStatus("Running..."), setTimeout(function () {
            setTimeout(function () {
              I.setStatus("");
            }, 1), g();
          }, 1)) : g()));
        }

        if (X = function A() {
          oA || yA(), oA || (X = A);
        }, I.run = yA, I.preInit) for ("function" == typeof I.preInit && (I.preInit = [I.preInit]); I.preInit.length > 0;) {
          I.preInit.pop()();
        }
        yA(), Object.keys(B).forEach(function (A) {
          "getRandomValue" !== A && delete B[A];
        }), Object.keys(I).forEach(function (A) {
          B[A] = I[A];
        });
      };
      var g,
          C = void 0 !== C ? C : {},
          Q = {};

      for (g in C) {
        C.hasOwnProperty(g) && (Q[g] = C[g]);
      }

      var E,
          i,
          e = [],
          o = !1,
          c = !1,
          a = !1;
      o = "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)), c = "function" == typeof importScripts, E = "object" == (typeof process === "undefined" ? "undefined" : _typeof(process)) && "object" == _typeof(process.versions) && "string" == typeof process.versions.node, a = E && !o && !c, i = !o && !a && !c;
      var n,
          r,
          t,
          f,
          w = "";
      a ? (w = __dirname + "/", n = function n(A, I) {
        var g;
        return (g = eA(A)) || (t || (t = __webpack_require__(/*! fs */ 0)), f || (f = __webpack_require__(/*! path */ "./node_modules/path-browserify/index.js")), A = f.normalize(A), g = t.readFileSync(A)), I ? g : g.toString();
      }, r = function r(A) {
        var I = n(A, !0);
        return I.buffer || (I = new Uint8Array(I)), H(I.buffer), I;
      }, process.argv.length > 1 && process.argv[1].replace(/\\/g, "/"), e = process.argv.slice(2),  true && (module.exports = C), process.on("unhandledRejection", z), C.inspect = function () {
        return "[Emscripten Module object]";
      }) : i ? ("undefined" != typeof read && (n = function n(A) {
        var I = eA(A);
        return I ? EA(I) : read(A);
      }), r = function r(A) {
        var I;
        return (I = eA(A)) ? I : "function" == typeof readbuffer ? new Uint8Array(readbuffer(A)) : (H("object" == _typeof(I = read(A, "binary"))), I);
      }, "undefined" != typeof scriptArgs ? e = scriptArgs : void 0 !== arguments && (e = arguments), "undefined" != typeof print && ("undefined" == typeof console && (console = {}), console.log = print, console.warn = console.error = "undefined" != typeof printErr ? printErr : print)) : (o || c) && (c ? w = self.location.href : document.currentScript && (w = document.currentScript.src), w = 0 !== w.indexOf("blob:") ? w.substr(0, w.lastIndexOf("/") + 1) : "", n = function n(A) {
        try {
          var I = new XMLHttpRequest();
          return I.open("GET", A, !1), I.send(null), I.responseText;
        } catch (I) {
          var g = eA(A);
          if (g) return EA(g);
          throw I;
        }
      }, c && (r = function r(A) {
        try {
          var I = new XMLHttpRequest();
          return I.open("GET", A, !1), I.responseType = "arraybuffer", I.send(null), new Uint8Array(I.response);
        } catch (I) {
          var g = eA(A);
          if (g) return g;
          throw I;
        }
      }));
      var y = C.print || void 0,
          s = C.printErr || void 0;

      for (g in Q) {
        Q.hasOwnProperty(g) && (C[g] = Q[g]);
      }

      Q = null, C.arguments && (e = C.arguments), C.thisProgram && C.thisProgram, C.quit && C.quit;
      var h,
          D,
          F = {
        "f64-rem": function f64Rem(A, I) {
          return A % I;
        },
        debugger: function _debugger() {}
      };
      new Array(8), C.wasmBinary && (h = C.wasmBinary), C.noExitRuntime && C.noExitRuntime, "object" != (typeof WebAssembly === "undefined" ? "undefined" : _typeof(WebAssembly)) && s("no native wasm support detected");
      var p = new WebAssembly.Table({
        initial: 0,
        maximum: 0,
        element: "anyfunc"
      }),
          u = !1;

      function H(A, I) {
        A || z("Assertion failed: " + I);
      }

      var k,
          l,
          _,
          G,
          _d2,
          Y,
          M,
          S = "undefined" != typeof TextDecoder ? new TextDecoder("utf8") : void 0;

      function U(A, I) {
        return A ? function (A, I, g) {
          for (var B = I + g, C = I; A[C] && !(C >= B);) {
            ++C;
          }

          if (C - I > 16 && A.subarray && S) return S.decode(A.subarray(I, C));

          for (var Q = ""; I < C;) {
            var E = A[I++];

            if (128 & E) {
              var i = 63 & A[I++];

              if (192 != (224 & E)) {
                var e = 63 & A[I++];
                if ((E = 224 == (240 & E) ? (15 & E) << 12 | i << 6 | e : (7 & E) << 18 | i << 12 | e << 6 | 63 & A[I++]) < 65536) Q += String.fromCharCode(E);else {
                  var o = E - 65536;
                  Q += String.fromCharCode(55296 | o >> 10, 56320 | 1023 & o);
                }
              } else Q += String.fromCharCode((31 & E) << 6 | i);
            } else Q += String.fromCharCode(E);
          }

          return Q;
        }(_, A, I) : "";
      }

      function v(A, I) {
        return A % I > 0 && (A += I - A % I), A;
      }

      function b(A) {
        k = A, C.HEAP8 = l = new Int8Array(A), C.HEAP16 = G = new Int16Array(A), C.HEAP32 = _d2 = new Int32Array(A), C.HEAPU8 = _ = new Uint8Array(A), C.HEAPU16 = new Uint16Array(A), C.HEAPU32 = new Uint32Array(A), C.HEAPF32 = Y = new Float32Array(A), C.HEAPF64 = M = new Float64Array(A);
      }

      "undefined" != typeof TextDecoder && new TextDecoder("utf-16le");
      var J = C.TOTAL_MEMORY || 16777216;

      function P(A) {
        for (; A.length > 0;) {
          var I = A.shift();

          if ("function" != typeof I) {
            var g = I.func;
            "number" == typeof g ? void 0 === I.arg ? C.dynCall_v(g) : C.dynCall_vi(g, I.arg) : g(void 0 === I.arg ? null : I.arg);
          } else I();
        }
      }

      (D = C.wasmMemory ? C.wasmMemory : new WebAssembly.Memory({
        initial: J / 65536
      })) && (k = D.buffer), J = k.byteLength, b(k), _d2[9312] = 5280320;
      var R = [],
          N = [],
          m = [],
          L = [],
          x = Math.abs,
          K = Math.ceil,
          X = Math.floor,
          j = Math.min,
          T = 0,
          q = null,
          V = null;

      function z(A) {
        throw C.onAbort && C.onAbort(A), y(A += ""), s(A), u = !0, "abort(" + A + "). Build with -s ASSERTIONS=1 for more info.";
      }

      C.preloadedImages = {}, C.preloadedAudios = {};
      var W = "data:application/octet-stream;base64,";

      function O(A) {
        return String.prototype.startsWith ? A.startsWith(W) : 0 === A.indexOf(W);
      }

      var Z,
          $,
          AA,
          IA = "data:application/octet-stream;base64, ";

      function gA() {
        try {
          if (h) return new Uint8Array(h);
          var A = eA(IA);
          if (A) return A;
          if (r) return r(IA);
          throw "both async and sync fetching of the wasm failed";
        } catch (A) {
          z(A);
        }
      }

      O(IA) || (Z = IA, IA = C.locateFile ? C.locateFile(Z, w) : w + Z), C.asm = function () {
        var A = {
          env: cA,
          wasi_unstable: cA,
          global: {
            NaN: NaN,
            Infinity: 1 / 0
          },
          "global.Math": Math,
          asm2wasm: F
        };

        function I(A, I) {
          var g = A.exports;
          C.asm = g, function (A) {
            if (T--, C.monitorRunDependencies && C.monitorRunDependencies(T), 0 == T && (null !== q && (clearInterval(q), q = null), V)) {
              var I = V;
              V = null, I();
            }
          }();
        }

        function g(A) {
          I(A.instance);
        }

        function B(I) {
          return (h || !o && !c || "function" != typeof fetch ? new Promise(function (A, I) {
            A(gA());
          }) : fetch(IA, {
            credentials: "same-origin"
          }).then(function (A) {
            if (!A.ok) throw "failed to load wasm binary file at '" + IA + "'";
            return A.arrayBuffer();
          }).catch(function () {
            return gA();
          })).then(function (I) {
            return WebAssembly.instantiate(I, A);
          }).then(I, function (A) {
            s("failed to asynchronously prepare wasm: " + A), z(A);
          });
        }

        if (T++, C.monitorRunDependencies && C.monitorRunDependencies(T), C.instantiateWasm) try {
          return C.instantiateWasm(A, I);
        } catch (A) {
          return s("Module.instantiateWasm callback failed with error: " + A), !1;
        }
        return function () {
          if (h || "function" != typeof WebAssembly.instantiateStreaming || O(IA) || "function" != typeof fetch) return B(g);
          fetch(IA, {
            credentials: "same-origin"
          }).then(function (I) {
            return WebAssembly.instantiateStreaming(I, A).then(g, function (A) {
              s("wasm streaming compile failed: " + A), s("falling back to ArrayBuffer instantiation"), B(g);
            });
          });
        }(), {};
      };
      var BA = [function () {
        return C.getRandomValue();
      }, function () {
        if (void 0 === C.getRandomValue) try {
          var A = "object" == (typeof window === "undefined" ? "undefined" : _typeof(window)) ? window : self,
              I = void 0 !== A.crypto ? A.crypto : A.msCrypto,
              g = function g() {
            var A = new Uint32Array(1);
            return I.getRandomValues(A), A[0] >>> 0;
          };

          g(), C.getRandomValue = g;
        } catch (A) {
          try {
            var B = __webpack_require__(/*! crypto */ "./node_modules/crypto-browserify/index.js"),
                Q = function Q() {
              var A = B.randomBytes(4);
              return (A[0] << 24 | A[1] << 16 | A[2] << 8 | A[3]) >>> 0;
            };

            Q(), C.getRandomValue = Q;
          } catch (A) {
            throw "No secure random number generator found";
          }
        }
      }];

      function CA() {
        return l.length;
      }

      var QA = !1;

      function EA(A) {
        for (var I = [], g = 0; g < A.length; g++) {
          var B = A[g];
          B > 255 && (QA && H(!1, "Character code " + B + " (" + String.fromCharCode(B) + ")  at offset " + g + " not in 0x00-0xFF."), B &= 255), I.push(String.fromCharCode(B));
        }

        return I.join("");
      }

      var iA = "function" == typeof atob ? atob : function (A) {
        var I,
            g,
            B,
            C,
            Q,
            E,
            i = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
            e = "",
            o = 0;
        A = A.replace(/[^A-Za-z0-9\+\/\=]/g, "");

        do {
          I = i.indexOf(A.charAt(o++)) << 2 | (C = i.indexOf(A.charAt(o++))) >> 4, g = (15 & C) << 4 | (Q = i.indexOf(A.charAt(o++))) >> 2, B = (3 & Q) << 6 | (E = i.indexOf(A.charAt(o++))), e += String.fromCharCode(I), 64 !== Q && (e += String.fromCharCode(g)), 64 !== E && (e += String.fromCharCode(B));
        } while (o < A.length);

        return e;
      };

      function eA(A) {
        if (O(A)) return function (A) {
          if ("boolean" == typeof a && a) {
            var I;

            try {
              I = Buffer.from(A, "base64");
            } catch (g) {
              I = new Buffer(A, "base64");
            }

            return new Uint8Array(I.buffer, I.byteOffset, I.byteLength);
          }

          try {
            for (var g = iA(A), B = new Uint8Array(g.length), C = 0; C < g.length; ++C) {
              B[C] = g.charCodeAt(C);
            }

            return B;
          } catch (A) {
            throw new Error("Converting base64 string to bytes failed.");
          }
        }(A.slice(W.length));
      }

      var oA,
          cA = {
        c: function c(A, I, g, B) {
          z("Assertion failed: " + U(A) + ", at: " + [I ? U(I) : "unknown filename", g, B ? U(B) : "unknown function"]);
        },
        __memory_base: 1024,
        __table_base: 0,
        a: function a() {
          z();
        },
        b: function b(A) {
          return BA[A]();
        },
        g: CA,
        f: function f(A, I, g) {
          _.set(_.subarray(I, I + g), A);
        },
        e: function e(A) {
          var I = CA();
          if (A > 2147418112) return !1;

          for (var g = Math.max(I, 16777216); g < A;) {
            g = g <= 536870912 ? v(2 * g, 65536) : Math.min(v((3 * g + 2147483648) / 4, 65536), 2147418112);
          }

          return !!function (A) {
            try {
              return D.grow(A - k.byteLength + 65535 >> 16), b(D.buffer), 1;
            } catch (A) {}
          }(g);
        },
        d: function d(A) {
          switch (A) {
            case 30:
              return 16384;

            case 85:
              return 131068;

            case 132:
            case 133:
            case 12:
            case 137:
            case 138:
            case 15:
            case 235:
            case 16:
            case 17:
            case 18:
            case 19:
            case 20:
            case 149:
            case 13:
            case 10:
            case 236:
            case 153:
            case 9:
            case 21:
            case 22:
            case 159:
            case 154:
            case 14:
            case 77:
            case 78:
            case 139:
            case 80:
            case 81:
            case 82:
            case 68:
            case 67:
            case 164:
            case 11:
            case 29:
            case 47:
            case 48:
            case 95:
            case 52:
            case 51:
            case 46:
              return 200809;

            case 79:
              return 0;

            case 27:
            case 246:
            case 127:
            case 128:
            case 23:
            case 24:
            case 160:
            case 161:
            case 181:
            case 182:
            case 242:
            case 183:
            case 184:
            case 243:
            case 244:
            case 245:
            case 165:
            case 178:
            case 179:
            case 49:
            case 50:
            case 168:
            case 169:
            case 175:
            case 170:
            case 171:
            case 172:
            case 97:
            case 76:
            case 32:
            case 173:
            case 35:
              return -1;

            case 176:
            case 177:
            case 7:
            case 155:
            case 8:
            case 157:
            case 125:
            case 126:
            case 92:
            case 93:
            case 129:
            case 130:
            case 131:
            case 94:
            case 91:
              return 1;

            case 74:
            case 60:
            case 69:
            case 70:
            case 4:
              return 1024;

            case 31:
            case 42:
            case 72:
              return 32;

            case 87:
            case 26:
            case 33:
              return 2147483647;

            case 34:
            case 1:
              return 47839;

            case 38:
            case 36:
              return 99;

            case 43:
            case 37:
              return 2048;

            case 0:
              return 2097152;

            case 3:
              return 65536;

            case 28:
              return 32768;

            case 44:
              return 32767;

            case 75:
              return 16384;

            case 39:
              return 1e3;

            case 89:
              return 700;

            case 71:
              return 256;

            case 40:
              return 255;

            case 2:
              return 100;

            case 180:
              return 64;

            case 25:
              return 20;

            case 5:
              return 16;

            case 6:
              return 6;

            case 73:
              return 4;

            case 84:
              return "object" == (typeof navigator === "undefined" ? "undefined" : _typeof(navigator)) && navigator.hardwareConcurrency || 1;
          }

          return C.___errno_location && (_d2[C.___errno_location() >> 2] = 28), -1;
        },
        memory: D,
        table: p
      },
          aA = C.asm({}, cA, k);

      function nA(A) {
        function I() {
          oA || (oA = !0, u || (P(N), P(m), C.onRuntimeInitialized && C.onRuntimeInitialized(), function () {
            if (C.postRun) for ("function" == typeof C.postRun && (C.postRun = [C.postRun]); C.postRun.length;) {
              A = C.postRun.shift(), L.unshift(A);
            }
            var A;
            P(L);
          }()));
        }

        A = A || e, T > 0 || (function () {
          if (C.preRun) for ("function" == typeof C.preRun && (C.preRun = [C.preRun]); C.preRun.length;) {
            A = C.preRun.shift(), R.unshift(A);
          }
          var A;
          P(R);
        }(), T > 0 || (C.setStatus ? (C.setStatus("Running..."), setTimeout(function () {
          setTimeout(function () {
            C.setStatus("");
          }, 1), I();
        }, 1)) : I()));
      }

      if (C.asm = aA, C.___errno_location = function () {
        return C.asm.h.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_abytes = function () {
        return C.asm.i.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_decrypt = function () {
        return C.asm.j.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_decrypt_detached = function () {
        return C.asm.k.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_encrypt = function () {
        return C.asm.l.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_encrypt_detached = function () {
        return C.asm.m.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_abytes = function () {
        return C.asm.n.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_decrypt = function () {
        return C.asm.o.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_decrypt_detached = function () {
        return C.asm.p.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_encrypt = function () {
        return C.asm.q.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_encrypt_detached = function () {
        return C.asm.r.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_keybytes = function () {
        return C.asm.s.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_keygen = function () {
        return C.asm.t.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_messagebytes_max = function () {
        return C.asm.u.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_npubbytes = function () {
        return C.asm.v.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_ietf_nsecbytes = function () {
        return C.asm.w.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_keybytes = function () {
        return C.asm.x.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_keygen = function () {
        return C.asm.y.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_messagebytes_max = function () {
        return C.asm.z.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_npubbytes = function () {
        return C.asm.A.apply(null, arguments);
      }, C._crypto_aead_chacha20poly1305_nsecbytes = function () {
        return C.asm.B.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_abytes = function () {
        return C.asm.C.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_decrypt = function () {
        return C.asm.D.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_decrypt_detached = function () {
        return C.asm.E.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_encrypt = function () {
        return C.asm.F.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_encrypt_detached = function () {
        return C.asm.G.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_keybytes = function () {
        return C.asm.H.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_keygen = function () {
        return C.asm.I.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_messagebytes_max = function () {
        return C.asm.J.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_npubbytes = function () {
        return C.asm.K.apply(null, arguments);
      }, C._crypto_aead_xchacha20poly1305_ietf_nsecbytes = function () {
        return C.asm.L.apply(null, arguments);
      }, C._crypto_auth = function () {
        return C.asm.M.apply(null, arguments);
      }, C._crypto_auth_bytes = function () {
        return C.asm.N.apply(null, arguments);
      }, C._crypto_auth_keybytes = function () {
        return C.asm.O.apply(null, arguments);
      }, C._crypto_auth_keygen = function () {
        return C.asm.P.apply(null, arguments);
      }, C._crypto_auth_verify = function () {
        return C.asm.Q.apply(null, arguments);
      }, C._crypto_box_beforenm = function () {
        return C.asm.R.apply(null, arguments);
      }, C._crypto_box_beforenmbytes = function () {
        return C.asm.S.apply(null, arguments);
      }, C._crypto_box_detached = function () {
        return C.asm.T.apply(null, arguments);
      }, C._crypto_box_detached_afternm = function () {
        return C.asm.U.apply(null, arguments);
      }, C._crypto_box_easy = function () {
        return C.asm.V.apply(null, arguments);
      }, C._crypto_box_easy_afternm = function () {
        return C.asm.W.apply(null, arguments);
      }, C._crypto_box_keypair = function () {
        return C.asm.X.apply(null, arguments);
      }, C._crypto_box_macbytes = function () {
        return C.asm.Y.apply(null, arguments);
      }, C._crypto_box_messagebytes_max = function () {
        return C.asm.Z.apply(null, arguments);
      }, C._crypto_box_noncebytes = function () {
        return C.asm._.apply(null, arguments);
      }, C._crypto_box_open_detached = function () {
        return C.asm.$.apply(null, arguments);
      }, C._crypto_box_open_detached_afternm = function () {
        return C.asm.aa.apply(null, arguments);
      }, C._crypto_box_open_easy = function () {
        return C.asm.ba.apply(null, arguments);
      }, C._crypto_box_open_easy_afternm = function () {
        return C.asm.ca.apply(null, arguments);
      }, C._crypto_box_publickeybytes = function () {
        return C.asm.da.apply(null, arguments);
      }, C._crypto_box_seal = function () {
        return C.asm.ea.apply(null, arguments);
      }, C._crypto_box_seal_open = function () {
        return C.asm.fa.apply(null, arguments);
      }, C._crypto_box_sealbytes = function () {
        return C.asm.ga.apply(null, arguments);
      }, C._crypto_box_secretkeybytes = function () {
        return C.asm.ha.apply(null, arguments);
      }, C._crypto_box_seed_keypair = function () {
        return C.asm.ia.apply(null, arguments);
      }, C._crypto_box_seedbytes = function () {
        return C.asm.ja.apply(null, arguments);
      }, C._crypto_generichash = function () {
        return C.asm.ka.apply(null, arguments);
      }, C._crypto_generichash_bytes = function () {
        return C.asm.la.apply(null, arguments);
      }, C._crypto_generichash_bytes_max = function () {
        return C.asm.ma.apply(null, arguments);
      }, C._crypto_generichash_bytes_min = function () {
        return C.asm.na.apply(null, arguments);
      }, C._crypto_generichash_final = function () {
        return C.asm.oa.apply(null, arguments);
      }, C._crypto_generichash_init = function () {
        return C.asm.pa.apply(null, arguments);
      }, C._crypto_generichash_keybytes = function () {
        return C.asm.qa.apply(null, arguments);
      }, C._crypto_generichash_keybytes_max = function () {
        return C.asm.ra.apply(null, arguments);
      }, C._crypto_generichash_keybytes_min = function () {
        return C.asm.sa.apply(null, arguments);
      }, C._crypto_generichash_keygen = function () {
        return C.asm.ta.apply(null, arguments);
      }, C._crypto_generichash_statebytes = function () {
        return C.asm.ua.apply(null, arguments);
      }, C._crypto_generichash_update = function () {
        return C.asm.va.apply(null, arguments);
      }, C._crypto_hash = function () {
        return C.asm.wa.apply(null, arguments);
      }, C._crypto_hash_bytes = function () {
        return C.asm.xa.apply(null, arguments);
      }, C._crypto_kdf_bytes_max = function () {
        return C.asm.ya.apply(null, arguments);
      }, C._crypto_kdf_bytes_min = function () {
        return C.asm.za.apply(null, arguments);
      }, C._crypto_kdf_contextbytes = function () {
        return C.asm.Aa.apply(null, arguments);
      }, C._crypto_kdf_derive_from_key = function () {
        return C.asm.Ba.apply(null, arguments);
      }, C._crypto_kdf_keybytes = function () {
        return C.asm.Ca.apply(null, arguments);
      }, C._crypto_kdf_keygen = function () {
        return C.asm.Da.apply(null, arguments);
      }, C._crypto_kx_client_session_keys = function () {
        return C.asm.Ea.apply(null, arguments);
      }, C._crypto_kx_keypair = function () {
        return C.asm.Fa.apply(null, arguments);
      }, C._crypto_kx_publickeybytes = function () {
        return C.asm.Ga.apply(null, arguments);
      }, C._crypto_kx_secretkeybytes = function () {
        return C.asm.Ha.apply(null, arguments);
      }, C._crypto_kx_seed_keypair = function () {
        return C.asm.Ia.apply(null, arguments);
      }, C._crypto_kx_seedbytes = function () {
        return C.asm.Ja.apply(null, arguments);
      }, C._crypto_kx_server_session_keys = function () {
        return C.asm.Ka.apply(null, arguments);
      }, C._crypto_kx_sessionkeybytes = function () {
        return C.asm.La.apply(null, arguments);
      }, C._crypto_pwhash = function () {
        return C.asm.Ma.apply(null, arguments);
      }, C._crypto_pwhash_alg_argon2i13 = function () {
        return C.asm.Na.apply(null, arguments);
      }, C._crypto_pwhash_alg_argon2id13 = function () {
        return C.asm.Oa.apply(null, arguments);
      }, C._crypto_pwhash_alg_default = function () {
        return C.asm.Pa.apply(null, arguments);
      }, C._crypto_pwhash_bytes_max = function () {
        return C.asm.Qa.apply(null, arguments);
      }, C._crypto_pwhash_bytes_min = function () {
        return C.asm.Ra.apply(null, arguments);
      }, C._crypto_pwhash_memlimit_interactive = function () {
        return C.asm.Sa.apply(null, arguments);
      }, C._crypto_pwhash_memlimit_max = function () {
        return C.asm.Ta.apply(null, arguments);
      }, C._crypto_pwhash_memlimit_min = function () {
        return C.asm.Ua.apply(null, arguments);
      }, C._crypto_pwhash_memlimit_moderate = function () {
        return C.asm.Va.apply(null, arguments);
      }, C._crypto_pwhash_memlimit_sensitive = function () {
        return C.asm.Wa.apply(null, arguments);
      }, C._crypto_pwhash_opslimit_interactive = function () {
        return C.asm.Xa.apply(null, arguments);
      }, C._crypto_pwhash_opslimit_max = function () {
        return C.asm.Ya.apply(null, arguments);
      }, C._crypto_pwhash_opslimit_min = function () {
        return C.asm.Za.apply(null, arguments);
      }, C._crypto_pwhash_opslimit_moderate = function () {
        return C.asm._a.apply(null, arguments);
      }, C._crypto_pwhash_opslimit_sensitive = function () {
        return C.asm.$a.apply(null, arguments);
      }, C._crypto_pwhash_passwd_max = function () {
        return C.asm.ab.apply(null, arguments);
      }, C._crypto_pwhash_passwd_min = function () {
        return C.asm.bb.apply(null, arguments);
      }, C._crypto_pwhash_saltbytes = function () {
        return C.asm.cb.apply(null, arguments);
      }, C._crypto_pwhash_str = function () {
        return C.asm.db.apply(null, arguments);
      }, C._crypto_pwhash_str_alg = function () {
        return C.asm.eb.apply(null, arguments);
      }, C._crypto_pwhash_str_needs_rehash = function () {
        return C.asm.fb.apply(null, arguments);
      }, C._crypto_pwhash_str_verify = function () {
        return C.asm.gb.apply(null, arguments);
      }, C._crypto_pwhash_strbytes = function () {
        return C.asm.hb.apply(null, arguments);
      }, C._crypto_pwhash_strprefix = function () {
        return C.asm.ib.apply(null, arguments);
      }, C._crypto_scalarmult = function () {
        return C.asm.jb.apply(null, arguments);
      }, C._crypto_scalarmult_base = function () {
        return C.asm.kb.apply(null, arguments);
      }, C._crypto_scalarmult_bytes = function () {
        return C.asm.lb.apply(null, arguments);
      }, C._crypto_scalarmult_scalarbytes = function () {
        return C.asm.mb.apply(null, arguments);
      }, C._crypto_secretbox_detached = function () {
        return C.asm.nb.apply(null, arguments);
      }, C._crypto_secretbox_easy = function () {
        return C.asm.ob.apply(null, arguments);
      }, C._crypto_secretbox_keybytes = function () {
        return C.asm.pb.apply(null, arguments);
      }, C._crypto_secretbox_keygen = function () {
        return C.asm.qb.apply(null, arguments);
      }, C._crypto_secretbox_macbytes = function () {
        return C.asm.rb.apply(null, arguments);
      }, C._crypto_secretbox_messagebytes_max = function () {
        return C.asm.sb.apply(null, arguments);
      }, C._crypto_secretbox_noncebytes = function () {
        return C.asm.tb.apply(null, arguments);
      }, C._crypto_secretbox_open_detached = function () {
        return C.asm.ub.apply(null, arguments);
      }, C._crypto_secretbox_open_easy = function () {
        return C.asm.vb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_abytes = function () {
        return C.asm.wb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_headerbytes = function () {
        return C.asm.xb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_init_pull = function () {
        return C.asm.yb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_init_push = function () {
        return C.asm.zb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_keybytes = function () {
        return C.asm.Ab.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_keygen = function () {
        return C.asm.Bb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_messagebytes_max = function () {
        return C.asm.Cb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_pull = function () {
        return C.asm.Db.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_push = function () {
        return C.asm.Eb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_rekey = function () {
        return C.asm.Fb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_statebytes = function () {
        return C.asm.Gb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_tag_final = function () {
        return C.asm.Hb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_tag_message = function () {
        return C.asm.Ib.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_tag_push = function () {
        return C.asm.Jb.apply(null, arguments);
      }, C._crypto_secretstream_xchacha20poly1305_tag_rekey = function () {
        return C.asm.Kb.apply(null, arguments);
      }, C._crypto_shorthash = function () {
        return C.asm.Lb.apply(null, arguments);
      }, C._crypto_shorthash_bytes = function () {
        return C.asm.Mb.apply(null, arguments);
      }, C._crypto_shorthash_keybytes = function () {
        return C.asm.Nb.apply(null, arguments);
      }, C._crypto_shorthash_keygen = function () {
        return C.asm.Ob.apply(null, arguments);
      }, C._crypto_sign = function () {
        return C.asm.Pb.apply(null, arguments);
      }, C._crypto_sign_bytes = function () {
        return C.asm.Qb.apply(null, arguments);
      }, C._crypto_sign_detached = function () {
        return C.asm.Rb.apply(null, arguments);
      }, C._crypto_sign_ed25519_pk_to_curve25519 = function () {
        return C.asm.Sb.apply(null, arguments);
      }, C._crypto_sign_ed25519_sk_to_curve25519 = function () {
        return C.asm.Tb.apply(null, arguments);
      }, C._crypto_sign_final_create = function () {
        return C.asm.Ub.apply(null, arguments);
      }, C._crypto_sign_final_verify = function () {
        return C.asm.Vb.apply(null, arguments);
      }, C._crypto_sign_init = function () {
        return C.asm.Wb.apply(null, arguments);
      }, C._crypto_sign_keypair = function () {
        return C.asm.Xb.apply(null, arguments);
      }, C._crypto_sign_messagebytes_max = function () {
        return C.asm.Yb.apply(null, arguments);
      }, C._crypto_sign_open = function () {
        return C.asm.Zb.apply(null, arguments);
      }, C._crypto_sign_publickeybytes = function () {
        return C.asm._b.apply(null, arguments);
      }, C._crypto_sign_secretkeybytes = function () {
        return C.asm.$b.apply(null, arguments);
      }, C._crypto_sign_seed_keypair = function () {
        return C.asm.ac.apply(null, arguments);
      }, C._crypto_sign_seedbytes = function () {
        return C.asm.bc.apply(null, arguments);
      }, C._crypto_sign_statebytes = function () {
        return C.asm.cc.apply(null, arguments);
      }, C._crypto_sign_update = function () {
        return C.asm.dc.apply(null, arguments);
      }, C._crypto_sign_verify_detached = function () {
        return C.asm.ec.apply(null, arguments);
      }, C._free = function () {
        return C.asm.fc.apply(null, arguments);
      }, C._malloc = function () {
        return C.asm.gc.apply(null, arguments);
      }, C._randombytes = function () {
        return C.asm.hc.apply(null, arguments);
      }, C._randombytes_buf = function () {
        return C.asm.ic.apply(null, arguments);
      }, C._randombytes_buf_deterministic = function () {
        return C.asm.jc.apply(null, arguments);
      }, C._randombytes_close = function () {
        return C.asm.kc.apply(null, arguments);
      }, C._randombytes_random = function () {
        return C.asm.lc.apply(null, arguments);
      }, C._randombytes_seedbytes = function () {
        return C.asm.mc.apply(null, arguments);
      }, C._randombytes_stir = function () {
        return C.asm.nc.apply(null, arguments);
      }, C._randombytes_uniform = function () {
        return C.asm.oc.apply(null, arguments);
      }, C._sodium_base642bin = function () {
        return C.asm.pc.apply(null, arguments);
      }, C._sodium_base64_encoded_len = function () {
        return C.asm.qc.apply(null, arguments);
      }, C._sodium_bin2base64 = function () {
        return C.asm.rc.apply(null, arguments);
      }, C._sodium_bin2hex = function () {
        return C.asm.sc.apply(null, arguments);
      }, C._sodium_hex2bin = function () {
        return C.asm.tc.apply(null, arguments);
      }, C._sodium_init = function () {
        return C.asm.uc.apply(null, arguments);
      }, C._sodium_library_minimal = function () {
        return C.asm.vc.apply(null, arguments);
      }, C._sodium_library_version_major = function () {
        return C.asm.wc.apply(null, arguments);
      }, C._sodium_library_version_minor = function () {
        return C.asm.xc.apply(null, arguments);
      }, C._sodium_pad = function () {
        return C.asm.yc.apply(null, arguments);
      }, C._sodium_unpad = function () {
        return C.asm.zc.apply(null, arguments);
      }, C._sodium_version_string = function () {
        return C.asm.Ac.apply(null, arguments);
      }, C.asm = aA, C.setValue = function (A, I, g, B) {
        switch ("*" === (g = g || "i8").charAt(g.length - 1) && (g = "i32"), g) {
          case "i1":
          case "i8":
            l[A >> 0] = I;
            break;

          case "i16":
            G[A >> 1] = I;
            break;

          case "i32":
            _d2[A >> 2] = I;
            break;

          case "i64":
            AA = [I >>> 0, ($ = I, +x($) >= 1 ? $ > 0 ? (0 | j(+X($ / 4294967296), 4294967295)) >>> 0 : ~~+K(($ - +(~~$ >>> 0)) / 4294967296) >>> 0 : 0)], _d2[A >> 2] = AA[0], _d2[A + 4 >> 2] = AA[1];
            break;

          case "float":
            Y[A >> 2] = I;
            break;

          case "double":
            M[A >> 3] = I;
            break;

          default:
            z("invalid type for setValue: " + g);
        }
      }, C.getValue = function (A, I, g) {
        switch ("*" === (I = I || "i8").charAt(I.length - 1) && (I = "i32"), I) {
          case "i1":
          case "i8":
            return l[A >> 0];

          case "i16":
            return G[A >> 1];

          case "i32":
          case "i64":
            return _d2[A >> 2];

          case "float":
            return Y[A >> 2];

          case "double":
            return M[A >> 3];

          default:
            z("invalid type for getValue: " + I);
        }

        return null;
      }, C.UTF8ToString = U, V = function A() {
        oA || nA(), oA || (V = A);
      }, C.run = nA, C.preInit) for ("function" == typeof C.preInit && (C.preInit = [C.preInit]); C.preInit.length > 0;) {
        C.preInit.pop()();
      }
      nA();
    }).catch(function () {
      B.useBackupModule();
    }), "object" == (typeof process === "undefined" ? "undefined" : _typeof(process)) && "function" == typeof process.removeAllListeners && (process.removeAllListeners("uncaughtException"), process.removeAllListeners("unhandledRejection")), I;
  }

   true ? !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (I),
				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : undefined;
}(this);
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../../../process/browser.js */ "./node_modules/process/browser.js"), "/", __webpack_require__(/*! ./../../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/md5.js/index.js":
/*!**************************************!*\
  !*** ./node_modules/md5.js/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var HashBase = __webpack_require__(/*! hash-base */ "./node_modules/hash-base/index.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var ARRAY16 = new Array(16);

function MD5() {
  HashBase.call(this, 64); // state

  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
}

inherits(MD5, HashBase);

MD5.prototype._update = function () {
  var M = ARRAY16;

  for (var i = 0; i < 16; ++i) {
    M[i] = this._block.readInt32LE(i * 4);
  }

  var a = this._a;
  var b = this._b;
  var c = this._c;
  var d = this._d;
  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7);
  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12);
  c = fnF(c, d, a, b, M[2], 0x242070db, 17);
  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22);
  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7);
  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12);
  c = fnF(c, d, a, b, M[6], 0xa8304613, 17);
  b = fnF(b, c, d, a, M[7], 0xfd469501, 22);
  a = fnF(a, b, c, d, M[8], 0x698098d8, 7);
  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12);
  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17);
  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22);
  a = fnF(a, b, c, d, M[12], 0x6b901122, 7);
  d = fnF(d, a, b, c, M[13], 0xfd987193, 12);
  c = fnF(c, d, a, b, M[14], 0xa679438e, 17);
  b = fnF(b, c, d, a, M[15], 0x49b40821, 22);
  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5);
  d = fnG(d, a, b, c, M[6], 0xc040b340, 9);
  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14);
  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20);
  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5);
  d = fnG(d, a, b, c, M[10], 0x02441453, 9);
  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14);
  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20);
  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5);
  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9);
  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14);
  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20);
  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5);
  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9);
  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14);
  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20);
  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4);
  d = fnH(d, a, b, c, M[8], 0x8771f681, 11);
  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16);
  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23);
  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4);
  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11);
  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16);
  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23);
  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4);
  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11);
  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16);
  b = fnH(b, c, d, a, M[6], 0x04881d05, 23);
  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4);
  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11);
  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16);
  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23);
  a = fnI(a, b, c, d, M[0], 0xf4292244, 6);
  d = fnI(d, a, b, c, M[7], 0x432aff97, 10);
  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15);
  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21);
  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6);
  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10);
  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15);
  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21);
  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6);
  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10);
  c = fnI(c, d, a, b, M[6], 0xa3014314, 15);
  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21);
  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6);
  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10);
  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15);
  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21);
  this._a = this._a + a | 0;
  this._b = this._b + b | 0;
  this._c = this._c + c | 0;
  this._d = this._d + d | 0;
};

MD5.prototype._digest = function () {
  // create padding and handle blocks
  this._block[this._blockOffset++] = 0x80;

  if (this._blockOffset > 56) {
    this._block.fill(0, this._blockOffset, 64);

    this._update();

    this._blockOffset = 0;
  }

  this._block.fill(0, this._blockOffset, 56);

  this._block.writeUInt32LE(this._length[0], 56);

  this._block.writeUInt32LE(this._length[1], 60);

  this._update(); // produce result


  var buffer = Buffer.allocUnsafe(16);
  buffer.writeInt32LE(this._a, 0);
  buffer.writeInt32LE(this._b, 4);
  buffer.writeInt32LE(this._c, 8);
  buffer.writeInt32LE(this._d, 12);
  return buffer;
};

function rotl(x, n) {
  return x << n | x >>> 32 - n;
}

function fnF(a, b, c, d, m, k, s) {
  return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
}

function fnG(a, b, c, d, m, k, s) {
  return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
}

function fnH(a, b, c, d, m, k, s) {
  return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
}

function fnI(a, b, c, d, m, k, s) {
  return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
}

module.exports = MD5;

/***/ }),

/***/ "./node_modules/miller-rabin/lib/mr.js":
/*!*********************************************!*\
  !*** ./node_modules/miller-rabin/lib/mr.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var bn = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var brorand = __webpack_require__(/*! brorand */ "./node_modules/brorand/index.js");

function MillerRabin(rand) {
  this.rand = rand || new brorand.Rand();
}

module.exports = MillerRabin;

MillerRabin.create = function create(rand) {
  return new MillerRabin(rand);
};

MillerRabin.prototype._randbelow = function _randbelow(n) {
  var len = n.bitLength();
  var min_bytes = Math.ceil(len / 8); // Generage random bytes until a number less than n is found.
  // This ensures that 0..n-1 have an equal probability of being selected.

  do {
    var a = new bn(this.rand.generate(min_bytes));
  } while (a.cmp(n) >= 0);

  return a;
};

MillerRabin.prototype._randrange = function _randrange(start, stop) {
  // Generate a random number greater than or equal to start and less than stop.
  var size = stop.sub(start);
  return start.add(this._randbelow(size));
};

MillerRabin.prototype.test = function test(n, k, cb) {
  var len = n.bitLength();
  var red = bn.mont(n);
  var rone = new bn(1).toRed(red);
  if (!k) k = Math.max(1, len / 48 | 0); // Find d and s, (n - 1) = (2 ^ s) * d;

  var n1 = n.subn(1);

  for (var s = 0; !n1.testn(s); s++) {}

  var d = n.shrn(s);
  var rn1 = n1.toRed(red);
  var prime = true;

  for (; k > 0; k--) {
    var a = this._randrange(new bn(2), n1);

    if (cb) cb(a);
    var x = a.toRed(red).redPow(d);
    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) continue;

    for (var i = 1; i < s; i++) {
      x = x.redSqr();
      if (x.cmp(rone) === 0) return false;
      if (x.cmp(rn1) === 0) break;
    }

    if (i === s) return false;
  }

  return prime;
};

MillerRabin.prototype.getDivisor = function getDivisor(n, k) {
  var len = n.bitLength();
  var red = bn.mont(n);
  var rone = new bn(1).toRed(red);
  if (!k) k = Math.max(1, len / 48 | 0); // Find d and s, (n - 1) = (2 ^ s) * d;

  var n1 = n.subn(1);

  for (var s = 0; !n1.testn(s); s++) {}

  var d = n.shrn(s);
  var rn1 = n1.toRed(red);

  for (; k > 0; k--) {
    var a = this._randrange(new bn(2), n1);

    var g = n.gcd(a);
    if (g.cmpn(1) !== 0) return g;
    var x = a.toRed(red).redPow(d);
    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0) continue;

    for (var i = 1; i < s; i++) {
      x = x.redSqr();
      if (x.cmp(rone) === 0) return x.fromRed().subn(1).gcd(n);
      if (x.cmp(rn1) === 0) break;
    }

    if (i === s) {
      x = x.redSqr();
      return x.fromRed().subn(1).gcd(n);
    }
  }

  return false;
};

/***/ }),

/***/ "./node_modules/minimalistic-assert/index.js":
/*!***************************************************!*\
  !*** ./node_modules/minimalistic-assert/index.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = assert;

function assert(val, msg) {
  if (!val) throw new Error(msg || 'Assertion failed');
}

assert.equal = function assertEqual(l, r, msg) {
  if (l != r) throw new Error(msg || 'Assertion failed: ' + l + ' != ' + r);
};

/***/ }),

/***/ "./node_modules/minimalistic-crypto-utils/lib/utils.js":
/*!*************************************************************!*\
  !*** ./node_modules/minimalistic-crypto-utils/lib/utils.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = exports;

function toArray(msg, enc) {
  if (Array.isArray(msg)) return msg.slice();
  if (!msg) return [];
  var res = [];

  if (typeof msg !== 'string') {
    for (var i = 0; i < msg.length; i++) {
      res[i] = msg[i] | 0;
    }

    return res;
  }

  if (enc === 'hex') {
    msg = msg.replace(/[^a-z0-9]+/ig, '');
    if (msg.length % 2 !== 0) msg = '0' + msg;

    for (var i = 0; i < msg.length; i += 2) {
      res.push(parseInt(msg[i] + msg[i + 1], 16));
    }
  } else {
    for (var i = 0; i < msg.length; i++) {
      var c = msg.charCodeAt(i);
      var hi = c >> 8;
      var lo = c & 0xff;
      if (hi) res.push(hi, lo);else res.push(lo);
    }
  }

  return res;
}

utils.toArray = toArray;

function zero2(word) {
  if (word.length === 1) return '0' + word;else return word;
}

utils.zero2 = zero2;

function toHex(msg) {
  var res = '';

  for (var i = 0; i < msg.length; i++) {
    res += zero2(msg[i].toString(16));
  }

  return res;
}

utils.toHex = toHex;

utils.encode = function encode(arr, enc) {
  if (enc === 'hex') return toHex(arr);else return arr;
};

/***/ }),

/***/ "./node_modules/parse-asn1/aesid.json":
/*!********************************************!*\
  !*** ./node_modules/parse-asn1/aesid.json ***!
  \********************************************/
/*! exports provided: 2.16.840.1.101.3.4.1.1, 2.16.840.1.101.3.4.1.2, 2.16.840.1.101.3.4.1.3, 2.16.840.1.101.3.4.1.4, 2.16.840.1.101.3.4.1.21, 2.16.840.1.101.3.4.1.22, 2.16.840.1.101.3.4.1.23, 2.16.840.1.101.3.4.1.24, 2.16.840.1.101.3.4.1.41, 2.16.840.1.101.3.4.1.42, 2.16.840.1.101.3.4.1.43, 2.16.840.1.101.3.4.1.44, default */
/***/ (function(module) {

module.exports = JSON.parse("{\"2.16.840.1.101.3.4.1.1\":\"aes-128-ecb\",\"2.16.840.1.101.3.4.1.2\":\"aes-128-cbc\",\"2.16.840.1.101.3.4.1.3\":\"aes-128-ofb\",\"2.16.840.1.101.3.4.1.4\":\"aes-128-cfb\",\"2.16.840.1.101.3.4.1.21\":\"aes-192-ecb\",\"2.16.840.1.101.3.4.1.22\":\"aes-192-cbc\",\"2.16.840.1.101.3.4.1.23\":\"aes-192-ofb\",\"2.16.840.1.101.3.4.1.24\":\"aes-192-cfb\",\"2.16.840.1.101.3.4.1.41\":\"aes-256-ecb\",\"2.16.840.1.101.3.4.1.42\":\"aes-256-cbc\",\"2.16.840.1.101.3.4.1.43\":\"aes-256-ofb\",\"2.16.840.1.101.3.4.1.44\":\"aes-256-cfb\"}");

/***/ }),

/***/ "./node_modules/parse-asn1/asn1.js":
/*!*****************************************!*\
  !*** ./node_modules/parse-asn1/asn1.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js
// Fedor, you are amazing.


var asn1 = __webpack_require__(/*! asn1.js */ "./node_modules/asn1.js/lib/asn1.js");

exports.certificate = __webpack_require__(/*! ./certificate */ "./node_modules/parse-asn1/certificate.js");
var RSAPrivateKey = asn1.define('RSAPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('modulus').int(), this.key('publicExponent').int(), this.key('privateExponent').int(), this.key('prime1').int(), this.key('prime2').int(), this.key('exponent1').int(), this.key('exponent2').int(), this.key('coefficient').int());
});
exports.RSAPrivateKey = RSAPrivateKey;
var RSAPublicKey = asn1.define('RSAPublicKey', function () {
  this.seq().obj(this.key('modulus').int(), this.key('publicExponent').int());
});
exports.RSAPublicKey = RSAPublicKey;
var PublicKey = asn1.define('SubjectPublicKeyInfo', function () {
  this.seq().obj(this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPublicKey').bitstr());
});
exports.PublicKey = PublicKey;
var AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {
  this.seq().obj(this.key('algorithm').objid(), this.key('none').null_().optional(), this.key('curve').objid().optional(), this.key('params').seq().obj(this.key('p').int(), this.key('q').int(), this.key('g').int()).optional());
});
var PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {
  this.seq().obj(this.key('version').int(), this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPrivateKey').octstr());
});
exports.PrivateKey = PrivateKeyInfo;
var EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {
  this.seq().obj(this.key('algorithm').seq().obj(this.key('id').objid(), this.key('decrypt').seq().obj(this.key('kde').seq().obj(this.key('id').objid(), this.key('kdeparams').seq().obj(this.key('salt').octstr(), this.key('iters').int())), this.key('cipher').seq().obj(this.key('algo').objid(), this.key('iv').octstr()))), this.key('subjectPrivateKey').octstr());
});
exports.EncryptedPrivateKey = EncryptedPrivateKeyInfo;
var DSAPrivateKey = asn1.define('DSAPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('p').int(), this.key('q').int(), this.key('g').int(), this.key('pub_key').int(), this.key('priv_key').int());
});
exports.DSAPrivateKey = DSAPrivateKey;
exports.DSAparam = asn1.define('DSAparam', function () {
  this.int();
});
var ECPrivateKey = asn1.define('ECPrivateKey', function () {
  this.seq().obj(this.key('version').int(), this.key('privateKey').octstr(), this.key('parameters').optional().explicit(0).use(ECParameters), this.key('publicKey').optional().explicit(1).bitstr());
});
exports.ECPrivateKey = ECPrivateKey;
var ECParameters = asn1.define('ECParameters', function () {
  this.choice({
    namedCurve: this.objid()
  });
});
exports.signature = asn1.define('signature', function () {
  this.seq().obj(this.key('r').int(), this.key('s').int());
});

/***/ }),

/***/ "./node_modules/parse-asn1/certificate.js":
/*!************************************************!*\
  !*** ./node_modules/parse-asn1/certificate.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js
// thanks to @Rantanen


var asn = __webpack_require__(/*! asn1.js */ "./node_modules/asn1.js/lib/asn1.js");

var Time = asn.define('Time', function () {
  this.choice({
    utcTime: this.utctime(),
    generalTime: this.gentime()
  });
});
var AttributeTypeValue = asn.define('AttributeTypeValue', function () {
  this.seq().obj(this.key('type').objid(), this.key('value').any());
});
var AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {
  this.seq().obj(this.key('algorithm').objid(), this.key('parameters').optional(), this.key('curve').objid().optional());
});
var SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {
  this.seq().obj(this.key('algorithm').use(AlgorithmIdentifier), this.key('subjectPublicKey').bitstr());
});
var RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {
  this.setof(AttributeTypeValue);
});
var RDNSequence = asn.define('RDNSequence', function () {
  this.seqof(RelativeDistinguishedName);
});
var Name = asn.define('Name', function () {
  this.choice({
    rdnSequence: this.use(RDNSequence)
  });
});
var Validity = asn.define('Validity', function () {
  this.seq().obj(this.key('notBefore').use(Time), this.key('notAfter').use(Time));
});
var Extension = asn.define('Extension', function () {
  this.seq().obj(this.key('extnID').objid(), this.key('critical').bool().def(false), this.key('extnValue').octstr());
});
var TBSCertificate = asn.define('TBSCertificate', function () {
  this.seq().obj(this.key('version').explicit(0).int().optional(), this.key('serialNumber').int(), this.key('signature').use(AlgorithmIdentifier), this.key('issuer').use(Name), this.key('validity').use(Validity), this.key('subject').use(Name), this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo), this.key('issuerUniqueID').implicit(1).bitstr().optional(), this.key('subjectUniqueID').implicit(2).bitstr().optional(), this.key('extensions').explicit(3).seqof(Extension).optional());
});
var X509Certificate = asn.define('X509Certificate', function () {
  this.seq().obj(this.key('tbsCertificate').use(TBSCertificate), this.key('signatureAlgorithm').use(AlgorithmIdentifier), this.key('signatureValue').bitstr());
});
module.exports = X509Certificate;

/***/ }),

/***/ "./node_modules/parse-asn1/fixProc.js":
/*!********************************************!*\
  !*** ./node_modules/parse-asn1/fixProc.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// adapted from https://github.com/apatil/pemstrip
var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r\+\/\=]+)[\n\r]+/m;
var startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m;
var fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r\+\/\=]+)-----END \1-----$/m;

var evp = __webpack_require__(/*! evp_bytestokey */ "./node_modules/evp_bytestokey/index.js");

var ciphers = __webpack_require__(/*! browserify-aes */ "./node_modules/browserify-aes/browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

module.exports = function (okey, password) {
  var key = okey.toString();
  var match = key.match(findProc);
  var decrypted;

  if (!match) {
    var match2 = key.match(fullRegex);
    decrypted = new Buffer(match2[2].replace(/[\r\n]/g, ''), 'base64');
  } else {
    var suite = 'aes' + match[1];
    var iv = Buffer.from(match[2], 'hex');
    var cipherText = Buffer.from(match[3].replace(/[\r\n]/g, ''), 'base64');
    var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key;
    var out = [];
    var cipher = ciphers.createDecipheriv(suite, cipherKey, iv);
    out.push(cipher.update(cipherText));
    out.push(cipher.final());
    decrypted = Buffer.concat(out);
  }

  var tag = key.match(startRegex)[1];
  return {
    tag: tag,
    data: decrypted
  };
};

/***/ }),

/***/ "./node_modules/parse-asn1/index.js":
/*!******************************************!*\
  !*** ./node_modules/parse-asn1/index.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var asn1 = __webpack_require__(/*! ./asn1 */ "./node_modules/parse-asn1/asn1.js");

var aesid = __webpack_require__(/*! ./aesid.json */ "./node_modules/parse-asn1/aesid.json");

var fixProc = __webpack_require__(/*! ./fixProc */ "./node_modules/parse-asn1/fixProc.js");

var ciphers = __webpack_require__(/*! browserify-aes */ "./node_modules/browserify-aes/browser.js");

var compat = __webpack_require__(/*! pbkdf2 */ "./node_modules/pbkdf2/browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

module.exports = parseKeys;

function parseKeys(buffer) {
  var password;

  if (_typeof(buffer) === 'object' && !Buffer.isBuffer(buffer)) {
    password = buffer.passphrase;
    buffer = buffer.key;
  }

  if (typeof buffer === 'string') {
    buffer = Buffer.from(buffer);
  }

  var stripped = fixProc(buffer, password);
  var type = stripped.tag;
  var data = stripped.data;
  var subtype, ndata;

  switch (type) {
    case 'CERTIFICATE':
      ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo;
    // falls through

    case 'PUBLIC KEY':
      if (!ndata) {
        ndata = asn1.PublicKey.decode(data, 'der');
      }

      subtype = ndata.algorithm.algorithm.join('.');

      switch (subtype) {
        case '1.2.840.113549.1.1.1':
          return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der');

        case '1.2.840.10045.2.1':
          ndata.subjectPrivateKey = ndata.subjectPublicKey;
          return {
            type: 'ec',
            data: ndata
          };

        case '1.2.840.10040.4.1':
          ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der');
          return {
            type: 'dsa',
            data: ndata.algorithm.params
          };

        default:
          throw new Error('unknown key id ' + subtype);
      }

      throw new Error('unknown key type ' + type);

    case 'ENCRYPTED PRIVATE KEY':
      data = asn1.EncryptedPrivateKey.decode(data, 'der');
      data = decrypt(data, password);
    // falls through

    case 'PRIVATE KEY':
      ndata = asn1.PrivateKey.decode(data, 'der');
      subtype = ndata.algorithm.algorithm.join('.');

      switch (subtype) {
        case '1.2.840.113549.1.1.1':
          return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der');

        case '1.2.840.10045.2.1':
          return {
            curve: ndata.algorithm.curve,
            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey
          };

        case '1.2.840.10040.4.1':
          ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der');
          return {
            type: 'dsa',
            params: ndata.algorithm.params
          };

        default:
          throw new Error('unknown key id ' + subtype);
      }

      throw new Error('unknown key type ' + type);

    case 'RSA PUBLIC KEY':
      return asn1.RSAPublicKey.decode(data, 'der');

    case 'RSA PRIVATE KEY':
      return asn1.RSAPrivateKey.decode(data, 'der');

    case 'DSA PRIVATE KEY':
      return {
        type: 'dsa',
        params: asn1.DSAPrivateKey.decode(data, 'der')
      };

    case 'EC PRIVATE KEY':
      data = asn1.ECPrivateKey.decode(data, 'der');
      return {
        curve: data.parameters.value,
        privateKey: data.privateKey
      };

    default:
      throw new Error('unknown key type ' + type);
  }
}

parseKeys.signature = asn1.signature;

function decrypt(data, password) {
  var salt = data.algorithm.decrypt.kde.kdeparams.salt;
  var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
  var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')];
  var iv = data.algorithm.decrypt.cipher.iv;
  var cipherText = data.subjectPrivateKey;
  var keylen = parseInt(algo.split('-')[1], 10) / 8;
  var key = compat.pbkdf2Sync(password, salt, iters, keylen, 'sha1');
  var cipher = ciphers.createDecipheriv(algo, key, iv);
  var out = [];
  out.push(cipher.update(cipherText));
  out.push(cipher.final());
  return Buffer.concat(out);
}

/***/ }),

/***/ "./node_modules/path-browserify/index.js":
/*!***********************************************!*\
  !*** ./node_modules/path-browserify/index.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(process) {// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,
// backported and transplited with Babel, with backwards-compat fixes
// 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.
// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
function normalizeArray(parts, allowAboveRoot) {
  // if the path tries to go above the root, `up` ends up > 0
  var up = 0;

  for (var i = parts.length - 1; i >= 0; i--) {
    var last = parts[i];

    if (last === '.') {
      parts.splice(i, 1);
    } else if (last === '..') {
      parts.splice(i, 1);
      up++;
    } else if (up) {
      parts.splice(i, 1);
      up--;
    }
  } // if the path is allowed to go above the root, restore leading ..s


  if (allowAboveRoot) {
    for (; up--; up) {
      parts.unshift('..');
    }
  }

  return parts;
} // path.resolve([from ...], to)
// posix version


exports.resolve = function () {
  var resolvedPath = '',
      resolvedAbsolute = false;

  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
    var path = i >= 0 ? arguments[i] : process.cwd(); // Skip empty and invalid entries

    if (typeof path !== 'string') {
      throw new TypeError('Arguments to path.resolve must be strings');
    } else if (!path) {
      continue;
    }

    resolvedPath = path + '/' + resolvedPath;
    resolvedAbsolute = path.charAt(0) === '/';
  } // At this point the path should be resolved to a full absolute path, but
  // handle relative paths to be safe (might happen when process.cwd() fails)
  // Normalize the path


  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function (p) {
    return !!p;
  }), !resolvedAbsolute).join('/');
  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
}; // path.normalize(path)
// posix version


exports.normalize = function (path) {
  var isAbsolute = exports.isAbsolute(path),
      trailingSlash = substr(path, -1) === '/'; // Normalize the path

  path = normalizeArray(filter(path.split('/'), function (p) {
    return !!p;
  }), !isAbsolute).join('/');

  if (!path && !isAbsolute) {
    path = '.';
  }

  if (path && trailingSlash) {
    path += '/';
  }

  return (isAbsolute ? '/' : '') + path;
}; // posix version


exports.isAbsolute = function (path) {
  return path.charAt(0) === '/';
}; // posix version


exports.join = function () {
  var paths = Array.prototype.slice.call(arguments, 0);
  return exports.normalize(filter(paths, function (p, index) {
    if (typeof p !== 'string') {
      throw new TypeError('Arguments to path.join must be strings');
    }

    return p;
  }).join('/'));
}; // path.relative(from, to)
// posix version


exports.relative = function (from, to) {
  from = exports.resolve(from).substr(1);
  to = exports.resolve(to).substr(1);

  function trim(arr) {
    var start = 0;

    for (; start < arr.length; start++) {
      if (arr[start] !== '') break;
    }

    var end = arr.length - 1;

    for (; end >= 0; end--) {
      if (arr[end] !== '') break;
    }

    if (start > end) return [];
    return arr.slice(start, end - start + 1);
  }

  var fromParts = trim(from.split('/'));
  var toParts = trim(to.split('/'));
  var length = Math.min(fromParts.length, toParts.length);
  var samePartsLength = length;

  for (var i = 0; i < length; i++) {
    if (fromParts[i] !== toParts[i]) {
      samePartsLength = i;
      break;
    }
  }

  var outputParts = [];

  for (var i = samePartsLength; i < fromParts.length; i++) {
    outputParts.push('..');
  }

  outputParts = outputParts.concat(toParts.slice(samePartsLength));
  return outputParts.join('/');
};

exports.sep = '/';
exports.delimiter = ':';

exports.dirname = function (path) {
  if (typeof path !== 'string') path = path + '';
  if (path.length === 0) return '.';
  var code = path.charCodeAt(0);
  var hasRoot = code === 47
  /*/*/
  ;
  var end = -1;
  var matchedSlash = true;

  for (var i = path.length - 1; i >= 1; --i) {
    code = path.charCodeAt(i);

    if (code === 47
    /*/*/
    ) {
        if (!matchedSlash) {
          end = i;
          break;
        }
      } else {
      // We saw the first non-path separator
      matchedSlash = false;
    }
  }

  if (end === -1) return hasRoot ? '/' : '.';

  if (hasRoot && end === 1) {
    // return '//';
    // Backwards-compat fix:
    return '/';
  }

  return path.slice(0, end);
};

function basename(path) {
  if (typeof path !== 'string') path = path + '';
  var start = 0;
  var end = -1;
  var matchedSlash = true;
  var i;

  for (i = path.length - 1; i >= 0; --i) {
    if (path.charCodeAt(i) === 47
    /*/*/
    ) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          start = i + 1;
          break;
        }
      } else if (end === -1) {
      // We saw the first non-path separator, mark this as the end of our
      // path component
      matchedSlash = false;
      end = i + 1;
    }
  }

  if (end === -1) return '';
  return path.slice(start, end);
} // Uses a mixed approach for backwards-compatibility, as ext behavior changed
// in new Node.js versions, so only basename() above is backported here


exports.basename = function (path, ext) {
  var f = basename(path);

  if (ext && f.substr(-1 * ext.length) === ext) {
    f = f.substr(0, f.length - ext.length);
  }

  return f;
};

exports.extname = function (path) {
  if (typeof path !== 'string') path = path + '';
  var startDot = -1;
  var startPart = 0;
  var end = -1;
  var matchedSlash = true; // Track the state of characters (if any) we see before our first dot and
  // after any path separator we find

  var preDotState = 0;

  for (var i = path.length - 1; i >= 0; --i) {
    var code = path.charCodeAt(i);

    if (code === 47
    /*/*/
    ) {
        // If we reached a path separator that was not part of a set of path
        // separators at the end of the string, stop now
        if (!matchedSlash) {
          startPart = i + 1;
          break;
        }

        continue;
      }

    if (end === -1) {
      // We saw the first non-path separator, mark this as the end of our
      // extension
      matchedSlash = false;
      end = i + 1;
    }

    if (code === 46
    /*.*/
    ) {
        // If this is our first dot, mark it as the start of our extension
        if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
      } else if (startDot !== -1) {
      // We saw a non-dot and non-path separator before our dot, so we should
      // have a good chance at having a non-empty extension
      preDotState = -1;
    }
  }

  if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
  preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
    return '';
  }

  return path.slice(startDot, end);
};

function filter(xs, f) {
  if (xs.filter) return xs.filter(f);
  var res = [];

  for (var i = 0; i < xs.length; i++) {
    if (f(xs[i], i, xs)) res.push(xs[i]);
  }

  return res;
} // String.prototype.substr - negative index don't work in IE8


var substr = 'ab'.substr(-1) === 'b' ? function (str, start, len) {
  return str.substr(start, len);
} : function (str, start, len) {
  if (start < 0) start = str.length + start;
  return str.substr(start, len);
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/pbkdf2/browser.js":
/*!****************************************!*\
  !*** ./node_modules/pbkdf2/browser.js ***!
  \****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

exports.pbkdf2 = __webpack_require__(/*! ./lib/async */ "./node_modules/pbkdf2/lib/async.js");
exports.pbkdf2Sync = __webpack_require__(/*! ./lib/sync */ "./node_modules/pbkdf2/lib/sync-browser.js");

/***/ }),

/***/ "./node_modules/pbkdf2/lib/async.js":
/*!******************************************!*\
  !*** ./node_modules/pbkdf2/lib/async.js ***!
  \******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global, process) {var checkParameters = __webpack_require__(/*! ./precondition */ "./node_modules/pbkdf2/lib/precondition.js");

var defaultEncoding = __webpack_require__(/*! ./default-encoding */ "./node_modules/pbkdf2/lib/default-encoding.js");

var sync = __webpack_require__(/*! ./sync */ "./node_modules/pbkdf2/lib/sync-browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var ZERO_BUF;
var subtle = global.crypto && global.crypto.subtle;
var toBrowser = {
  'sha': 'SHA-1',
  'sha-1': 'SHA-1',
  'sha1': 'SHA-1',
  'sha256': 'SHA-256',
  'sha-256': 'SHA-256',
  'sha384': 'SHA-384',
  'sha-384': 'SHA-384',
  'sha-512': 'SHA-512',
  'sha512': 'SHA-512'
};
var checks = [];

function checkNative(algo) {
  if (global.process && !global.process.browser) {
    return Promise.resolve(false);
  }

  if (!subtle || !subtle.importKey || !subtle.deriveBits) {
    return Promise.resolve(false);
  }

  if (checks[algo] !== undefined) {
    return checks[algo];
  }

  ZERO_BUF = ZERO_BUF || Buffer.alloc(8);
  var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(function () {
    return true;
  }).catch(function () {
    return false;
  });
  checks[algo] = prom;
  return prom;
}

function browserPbkdf2(password, salt, iterations, length, algo) {
  return subtle.importKey('raw', password, {
    name: 'PBKDF2'
  }, false, ['deriveBits']).then(function (key) {
    return subtle.deriveBits({
      name: 'PBKDF2',
      salt: salt,
      iterations: iterations,
      hash: {
        name: algo
      }
    }, key, length << 3);
  }).then(function (res) {
    return Buffer.from(res);
  });
}

function resolvePromise(promise, callback) {
  promise.then(function (out) {
    process.nextTick(function () {
      callback(null, out);
    });
  }, function (e) {
    process.nextTick(function () {
      callback(e);
    });
  });
}

module.exports = function (password, salt, iterations, keylen, digest, callback) {
  if (typeof digest === 'function') {
    callback = digest;
    digest = undefined;
  }

  digest = digest || 'sha1';
  var algo = toBrowser[digest.toLowerCase()];

  if (!algo || typeof global.Promise !== 'function') {
    return process.nextTick(function () {
      var out;

      try {
        out = sync(password, salt, iterations, keylen, digest);
      } catch (e) {
        return callback(e);
      }

      callback(null, out);
    });
  }

  checkParameters(password, salt, iterations, keylen);
  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2');
  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding);
  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding);
  resolvePromise(checkNative(algo).then(function (resp) {
    if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo);
    return sync(password, salt, iterations, keylen, digest);
  }), callback);
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/pbkdf2/lib/default-encoding.js":
/*!*****************************************************!*\
  !*** ./node_modules/pbkdf2/lib/default-encoding.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(process) {var defaultEncoding;
/* istanbul ignore next */

if (process.browser) {
  defaultEncoding = 'utf-8';
} else {
  var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10);
  defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary';
}

module.exports = defaultEncoding;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/pbkdf2/lib/precondition.js":
/*!*************************************************!*\
  !*** ./node_modules/pbkdf2/lib/precondition.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(Buffer) {var MAX_ALLOC = Math.pow(2, 30) - 1; // default in iojs

function checkBuffer(buf, name) {
  if (typeof buf !== 'string' && !Buffer.isBuffer(buf)) {
    throw new TypeError(name + ' must be a buffer or string');
  }
}

module.exports = function (password, salt, iterations, keylen) {
  checkBuffer(password, 'Password');
  checkBuffer(salt, 'Salt');

  if (typeof iterations !== 'number') {
    throw new TypeError('Iterations not a number');
  }

  if (iterations < 0) {
    throw new TypeError('Bad iterations');
  }

  if (typeof keylen !== 'number') {
    throw new TypeError('Key length not a number');
  }

  if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
    /* eslint no-self-compare: 0 */
    throw new TypeError('Bad key length');
  }
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node-libs-browser/node_modules/buffer/index.js */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/pbkdf2/lib/sync-browser.js":
/*!*************************************************!*\
  !*** ./node_modules/pbkdf2/lib/sync-browser.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var md5 = __webpack_require__(/*! create-hash/md5 */ "./node_modules/create-hash/md5.js");

var RIPEMD160 = __webpack_require__(/*! ripemd160 */ "./node_modules/ripemd160/index.js");

var sha = __webpack_require__(/*! sha.js */ "./node_modules/sha.js/index.js");

var checkParameters = __webpack_require__(/*! ./precondition */ "./node_modules/pbkdf2/lib/precondition.js");

var defaultEncoding = __webpack_require__(/*! ./default-encoding */ "./node_modules/pbkdf2/lib/default-encoding.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var ZEROS = Buffer.alloc(128);
var sizes = {
  md5: 16,
  sha1: 20,
  sha224: 28,
  sha256: 32,
  sha384: 48,
  sha512: 64,
  rmd160: 20,
  ripemd160: 20
};

function Hmac(alg, key, saltLen) {
  var hash = getDigest(alg);
  var blocksize = alg === 'sha512' || alg === 'sha384' ? 128 : 64;

  if (key.length > blocksize) {
    key = hash(key);
  } else if (key.length < blocksize) {
    key = Buffer.concat([key, ZEROS], blocksize);
  }

  var ipad = Buffer.allocUnsafe(blocksize + sizes[alg]);
  var opad = Buffer.allocUnsafe(blocksize + sizes[alg]);

  for (var i = 0; i < blocksize; i++) {
    ipad[i] = key[i] ^ 0x36;
    opad[i] = key[i] ^ 0x5C;
  }

  var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4);
  ipad.copy(ipad1, 0, 0, blocksize);
  this.ipad1 = ipad1;
  this.ipad2 = ipad;
  this.opad = opad;
  this.alg = alg;
  this.blocksize = blocksize;
  this.hash = hash;
  this.size = sizes[alg];
}

Hmac.prototype.run = function (data, ipad) {
  data.copy(ipad, this.blocksize);
  var h = this.hash(ipad);
  h.copy(this.opad, this.blocksize);
  return this.hash(this.opad);
};

function getDigest(alg) {
  function shaFunc(data) {
    return sha(alg).update(data).digest();
  }

  function rmd160Func(data) {
    return new RIPEMD160().update(data).digest();
  }

  if (alg === 'rmd160' || alg === 'ripemd160') return rmd160Func;
  if (alg === 'md5') return md5;
  return shaFunc;
}

function pbkdf2(password, salt, iterations, keylen, digest) {
  checkParameters(password, salt, iterations, keylen);
  if (!Buffer.isBuffer(password)) password = Buffer.from(password, defaultEncoding);
  if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, defaultEncoding);
  digest = digest || 'sha1';
  var hmac = new Hmac(digest, password, salt.length);
  var DK = Buffer.allocUnsafe(keylen);
  var block1 = Buffer.allocUnsafe(salt.length + 4);
  salt.copy(block1, 0, 0, salt.length);
  var destPos = 0;
  var hLen = sizes[digest];
  var l = Math.ceil(keylen / hLen);

  for (var i = 1; i <= l; i++) {
    block1.writeUInt32BE(i, salt.length);
    var T = hmac.run(block1, hmac.ipad1);
    var U = T;

    for (var j = 1; j < iterations; j++) {
      U = hmac.run(U, hmac.ipad2);

      for (var k = 0; k < hLen; k++) {
        T[k] ^= U[k];
      }
    }

    T.copy(DK, destPos);
    destPos += hLen;
  }

  return DK;
}

module.exports = pbkdf2;

/***/ }),

/***/ "./node_modules/process-nextick-args/index.js":
/*!****************************************************!*\
  !*** ./node_modules/process-nextick-args/index.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process) {

if (typeof process === 'undefined' || !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);
      });
  }
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/process/browser.js":
/*!*****************************************!*\
  !*** ./node_modules/process/browser.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(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;
};

/***/ }),

/***/ "./node_modules/public-encrypt/browser.js":
/*!************************************************!*\
  !*** ./node_modules/public-encrypt/browser.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

exports.publicEncrypt = __webpack_require__(/*! ./publicEncrypt */ "./node_modules/public-encrypt/publicEncrypt.js");
exports.privateDecrypt = __webpack_require__(/*! ./privateDecrypt */ "./node_modules/public-encrypt/privateDecrypt.js");

exports.privateEncrypt = function privateEncrypt(key, buf) {
  return exports.publicEncrypt(key, buf, true);
};

exports.publicDecrypt = function publicDecrypt(key, buf) {
  return exports.privateDecrypt(key, buf, true);
};

/***/ }),

/***/ "./node_modules/public-encrypt/mgf.js":
/*!********************************************!*\
  !*** ./node_modules/public-encrypt/mgf.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var createHash = __webpack_require__(/*! create-hash */ "./node_modules/create-hash/browser.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

module.exports = function (seed, len) {
  var t = Buffer.alloc(0);
  var i = 0;
  var c;

  while (t.length < len) {
    c = i2ops(i++);
    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()]);
  }

  return t.slice(0, len);
};

function i2ops(c) {
  var out = Buffer.allocUnsafe(4);
  out.writeUInt32BE(c, 0);
  return out;
}

/***/ }),

/***/ "./node_modules/public-encrypt/privateDecrypt.js":
/*!*******************************************************!*\
  !*** ./node_modules/public-encrypt/privateDecrypt.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var parseKeys = __webpack_require__(/*! parse-asn1 */ "./node_modules/parse-asn1/index.js");

var mgf = __webpack_require__(/*! ./mgf */ "./node_modules/public-encrypt/mgf.js");

var xor = __webpack_require__(/*! ./xor */ "./node_modules/public-encrypt/xor.js");

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var crt = __webpack_require__(/*! browserify-rsa */ "./node_modules/browserify-rsa/index.js");

var createHash = __webpack_require__(/*! create-hash */ "./node_modules/create-hash/browser.js");

var withPublic = __webpack_require__(/*! ./withPublic */ "./node_modules/public-encrypt/withPublic.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

module.exports = function privateDecrypt(privateKey, enc, reverse) {
  var padding;

  if (privateKey.padding) {
    padding = privateKey.padding;
  } else if (reverse) {
    padding = 1;
  } else {
    padding = 4;
  }

  var key = parseKeys(privateKey);
  var k = key.modulus.byteLength();

  if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {
    throw new Error('decryption error');
  }

  var msg;

  if (reverse) {
    msg = withPublic(new BN(enc), key);
  } else {
    msg = crt(enc, key);
  }

  var zBuffer = Buffer.alloc(k - msg.length);
  msg = Buffer.concat([zBuffer, msg], k);

  if (padding === 4) {
    return oaep(key, msg);
  } else if (padding === 1) {
    return pkcs1(key, msg, reverse);
  } else if (padding === 3) {
    return msg;
  } else {
    throw new Error('unknown padding');
  }
};

function oaep(key, msg) {
  var k = key.modulus.byteLength();
  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest();
  var hLen = iHash.length;

  if (msg[0] !== 0) {
    throw new Error('decryption error');
  }

  var maskedSeed = msg.slice(1, hLen + 1);
  var maskedDb = msg.slice(hLen + 1);
  var seed = xor(maskedSeed, mgf(maskedDb, hLen));
  var db = xor(maskedDb, mgf(seed, k - hLen - 1));

  if (compare(iHash, db.slice(0, hLen))) {
    throw new Error('decryption error');
  }

  var i = hLen;

  while (db[i] === 0) {
    i++;
  }

  if (db[i++] !== 1) {
    throw new Error('decryption error');
  }

  return db.slice(i);
}

function pkcs1(key, msg, reverse) {
  var p1 = msg.slice(0, 2);
  var i = 2;
  var status = 0;

  while (msg[i++] !== 0) {
    if (i >= msg.length) {
      status++;
      break;
    }
  }

  var ps = msg.slice(2, i - 1);

  if (p1.toString('hex') !== '0002' && !reverse || p1.toString('hex') !== '0001' && reverse) {
    status++;
  }

  if (ps.length < 8) {
    status++;
  }

  if (status) {
    throw new Error('decryption error');
  }

  return msg.slice(i);
}

function compare(a, b) {
  a = Buffer.from(a);
  b = Buffer.from(b);
  var dif = 0;
  var len = a.length;

  if (a.length !== b.length) {
    dif++;
    len = Math.min(a.length, b.length);
  }

  var i = -1;

  while (++i < len) {
    dif += a[i] ^ b[i];
  }

  return dif;
}

/***/ }),

/***/ "./node_modules/public-encrypt/publicEncrypt.js":
/*!******************************************************!*\
  !*** ./node_modules/public-encrypt/publicEncrypt.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var parseKeys = __webpack_require__(/*! parse-asn1 */ "./node_modules/parse-asn1/index.js");

var randomBytes = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");

var createHash = __webpack_require__(/*! create-hash */ "./node_modules/create-hash/browser.js");

var mgf = __webpack_require__(/*! ./mgf */ "./node_modules/public-encrypt/mgf.js");

var xor = __webpack_require__(/*! ./xor */ "./node_modules/public-encrypt/xor.js");

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var withPublic = __webpack_require__(/*! ./withPublic */ "./node_modules/public-encrypt/withPublic.js");

var crt = __webpack_require__(/*! browserify-rsa */ "./node_modules/browserify-rsa/index.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

module.exports = function publicEncrypt(publicKey, msg, reverse) {
  var padding;

  if (publicKey.padding) {
    padding = publicKey.padding;
  } else if (reverse) {
    padding = 1;
  } else {
    padding = 4;
  }

  var key = parseKeys(publicKey);
  var paddedMsg;

  if (padding === 4) {
    paddedMsg = oaep(key, msg);
  } else if (padding === 1) {
    paddedMsg = pkcs1(key, msg, reverse);
  } else if (padding === 3) {
    paddedMsg = new BN(msg);

    if (paddedMsg.cmp(key.modulus) >= 0) {
      throw new Error('data too long for modulus');
    }
  } else {
    throw new Error('unknown padding');
  }

  if (reverse) {
    return crt(paddedMsg, key);
  } else {
    return withPublic(paddedMsg, key);
  }
};

function oaep(key, msg) {
  var k = key.modulus.byteLength();
  var mLen = msg.length;
  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest();
  var hLen = iHash.length;
  var hLen2 = 2 * hLen;

  if (mLen > k - hLen2 - 2) {
    throw new Error('message too long');
  }

  var ps = Buffer.alloc(k - mLen - hLen2 - 2);
  var dblen = k - hLen - 1;
  var seed = randomBytes(hLen);
  var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen));
  var maskedSeed = xor(seed, mgf(maskedDb, hLen));
  return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k));
}

function pkcs1(key, msg, reverse) {
  var mLen = msg.length;
  var k = key.modulus.byteLength();

  if (mLen > k - 11) {
    throw new Error('message too long');
  }

  var ps;

  if (reverse) {
    ps = Buffer.alloc(k - mLen - 3, 0xff);
  } else {
    ps = nonZero(k - mLen - 3);
  }

  return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k));
}

function nonZero(len) {
  var out = Buffer.allocUnsafe(len);
  var i = 0;
  var cache = randomBytes(len * 2);
  var cur = 0;
  var num;

  while (i < len) {
    if (cur === cache.length) {
      cache = randomBytes(len * 2);
      cur = 0;
    }

    num = cache[cur++];

    if (num) {
      out[i++] = num;
    }
  }

  return out;
}

/***/ }),

/***/ "./node_modules/public-encrypt/withPublic.js":
/*!***************************************************!*\
  !*** ./node_modules/public-encrypt/withPublic.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var BN = __webpack_require__(/*! bn.js */ "./node_modules/bn.js/lib/bn.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

function withPublic(paddedMsg, key) {
  return Buffer.from(paddedMsg.toRed(BN.mont(key.modulus)).redPow(new BN(key.publicExponent)).fromRed().toArray());
}

module.exports = withPublic;

/***/ }),

/***/ "./node_modules/public-encrypt/xor.js":
/*!********************************************!*\
  !*** ./node_modules/public-encrypt/xor.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function xor(a, b) {
  var len = a.length;
  var i = -1;

  while (++i < len) {
    a[i] ^= b[i];
  }

  return a;
};

/***/ }),

/***/ "./node_modules/randombytes/browser.js":
/*!*********************************************!*\
  !*** ./node_modules/randombytes/browser.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global, process) { // limit of Crypto.getRandomValues()
// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues

var MAX_BYTES = 65536; // Node supports requesting up to this number of bytes
// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48

var MAX_UINT32 = 4294967295;

function oldBrowser() {
  throw new Error('Secure random number generation is not supported by this browser.\nUse Chrome, Firefox or Internet Explorer 11');
}

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var crypto = global.crypto || global.msCrypto;

if (crypto && crypto.getRandomValues) {
  module.exports = randomBytes;
} else {
  module.exports = oldBrowser;
}

function randomBytes(size, cb) {
  // phantomjs needs to throw
  if (size > MAX_UINT32) throw new RangeError('requested too many random bytes');
  var bytes = Buffer.allocUnsafe(size);

  if (size > 0) {
    // getRandomValues fails on IE if size == 0
    if (size > MAX_BYTES) {
      // this is the max bytes crypto.getRandomValues
      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
      for (var generated = 0; generated < size; generated += MAX_BYTES) {
        // buffer.slice automatically checks if the end is past the end of
        // the buffer so we don't have to here
        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES));
      }
    } else {
      crypto.getRandomValues(bytes);
    }
  }

  if (typeof cb === 'function') {
    return process.nextTick(function () {
      cb(null, bytes);
    });
  }

  return bytes;
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/randomfill/browser.js":
/*!********************************************!*\
  !*** ./node_modules/randomfill/browser.js ***!
  \********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global, process) {

function oldBrowser() {
  throw new Error('secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11');
}

var safeBuffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js");

var randombytes = __webpack_require__(/*! randombytes */ "./node_modules/randombytes/browser.js");

var Buffer = safeBuffer.Buffer;
var kBufferMaxLength = safeBuffer.kMaxLength;
var crypto = global.crypto || global.msCrypto;
var kMaxUint32 = Math.pow(2, 32) - 1;

function assertOffset(offset, length) {
  if (typeof offset !== 'number' || offset !== offset) {
    // eslint-disable-line no-self-compare
    throw new TypeError('offset must be a number');
  }

  if (offset > kMaxUint32 || offset < 0) {
    throw new TypeError('offset must be a uint32');
  }

  if (offset > kBufferMaxLength || offset > length) {
    throw new RangeError('offset out of range');
  }
}

function assertSize(size, offset, length) {
  if (typeof size !== 'number' || size !== size) {
    // eslint-disable-line no-self-compare
    throw new TypeError('size must be a number');
  }

  if (size > kMaxUint32 || size < 0) {
    throw new TypeError('size must be a uint32');
  }

  if (size + offset > length || size > kBufferMaxLength) {
    throw new RangeError('buffer too small');
  }
}

if (crypto && crypto.getRandomValues || !process.browser) {
  exports.randomFill = randomFill;
  exports.randomFillSync = randomFillSync;
} else {
  exports.randomFill = oldBrowser;
  exports.randomFillSync = oldBrowser;
}

function randomFill(buf, offset, size, cb) {
  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
    throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
  }

  if (typeof offset === 'function') {
    cb = offset;
    offset = 0;
    size = buf.length;
  } else if (typeof size === 'function') {
    cb = size;
    size = buf.length - offset;
  } else if (typeof cb !== 'function') {
    throw new TypeError('"cb" argument must be a function');
  }

  assertOffset(offset, buf.length);
  assertSize(size, offset, buf.length);
  return actualFill(buf, offset, size, cb);
}

function actualFill(buf, offset, size, cb) {
  if (process.browser) {
    var ourBuf = buf.buffer;
    var uint = new Uint8Array(ourBuf, offset, size);
    crypto.getRandomValues(uint);

    if (cb) {
      process.nextTick(function () {
        cb(null, buf);
      });
      return;
    }

    return buf;
  }

  if (cb) {
    randombytes(size, function (err, bytes) {
      if (err) {
        return cb(err);
      }

      bytes.copy(buf, offset);
      cb(null, buf);
    });
    return;
  }

  var bytes = randombytes(size);
  bytes.copy(buf, offset);
  return buf;
}

function randomFillSync(buf, offset, size) {
  if (typeof offset === 'undefined') {
    offset = 0;
  }

  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {
    throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
  }

  assertOffset(offset, buf.length);
  if (size === undefined) size = buf.length - offset;
  assertSize(size, offset, buf.length);
  return actualFill(buf, offset, size);
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/readable-stream/duplex-browser.js":
/*!********************************************************!*\
  !*** ./node_modules/readable-stream/duplex-browser.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./lib/_stream_duplex.js */ "./node_modules/readable-stream/lib/_stream_duplex.js");

/***/ }),

/***/ "./node_modules/readable-stream/lib/_stream_duplex.js":
/*!************************************************************!*\
  !*** ./node_modules/readable-stream/lib/_stream_duplex.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 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.

/*<replacement>*/

var pna = __webpack_require__(/*! process-nextick-args */ "./node_modules/process-nextick-args/index.js");
/*</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 = Object.create(__webpack_require__(/*! core-util-is */ "./node_modules/core-util-is/lib/util.js"));
util.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
/*</replacement>*/

var Readable = __webpack_require__(/*! ./_stream_readable */ "./node_modules/readable-stream/lib/_stream_readable.js");

var Writable = __webpack_require__(/*! ./_stream_writable */ "./node_modules/readable-stream/lib/_stream_writable.js");

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 get() {
    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 get() {
    if (this._readableState === undefined || this._writableState === undefined) {
      return false;
    }

    return this._readableState.destroyed && this._writableState.destroyed;
  },
  set: function set(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);
};

/***/ }),

/***/ "./node_modules/readable-stream/lib/_stream_passthrough.js":
/*!*****************************************************************!*\
  !*** ./node_modules/readable-stream/lib/_stream_passthrough.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 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.


module.exports = PassThrough;

var Transform = __webpack_require__(/*! ./_stream_transform */ "./node_modules/readable-stream/lib/_stream_transform.js");
/*<replacement>*/


var util = Object.create(__webpack_require__(/*! core-util-is */ "./node_modules/core-util-is/lib/util.js"));
util.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
/*</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);
};

/***/ }),

/***/ "./node_modules/readable-stream/lib/_stream_readable.js":
/*!**************************************************************!*\
  !*** ./node_modules/readable-stream/lib/_stream_readable.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global, process) {// 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.

/*<replacement>*/

var pna = __webpack_require__(/*! process-nextick-args */ "./node_modules/process-nextick-args/index.js");
/*</replacement>*/


module.exports = Readable;
/*<replacement>*/

var isArray = __webpack_require__(/*! isarray */ "./node_modules/isarray/index.js");
/*</replacement>*/

/*<replacement>*/


var Duplex;
/*</replacement>*/

Readable.ReadableState = ReadableState;
/*<replacement>*/

var EE = __webpack_require__(/*! events */ "./node_modules/events/events.js").EventEmitter;

var EElistenerCount = function EElistenerCount(emitter, type) {
  return emitter.listeners(type).length;
};
/*</replacement>*/

/*<replacement>*/


var Stream = __webpack_require__(/*! ./internal/streams/stream */ "./node_modules/readable-stream/lib/internal/streams/stream-browser.js");
/*</replacement>*/

/*<replacement>*/


var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").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 = Object.create(__webpack_require__(/*! core-util-is */ "./node_modules/core-util-is/lib/util.js"));
util.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
/*</replacement>*/

/*<replacement>*/

var debugUtil = __webpack_require__(/*! util */ 1);

var debug = void 0;

if (debugUtil && debugUtil.debuglog) {
  debug = debugUtil.debuglog('stream');
} else {
  debug = function debug() {};
}
/*</replacement>*/


var BufferList = __webpack_require__(/*! ./internal/streams/BufferList */ "./node_modules/readable-stream/lib/internal/streams/BufferList.js");

var destroyImpl = __webpack_require__(/*! ./internal/streams/destroy */ "./node_modules/readable-stream/lib/internal/streams/destroy.js");

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 || __webpack_require__(/*! ./_stream_duplex */ "./node_modules/readable-stream/lib/_stream_duplex.js");
  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 = __webpack_require__(/*! string_decoder/ */ "./node_modules/string_decoder/lib/string_decoder.js").StringDecoder;
    this.decoder = new StringDecoder(options.encoding);
    this.encoding = options.encoding;
  }
}

function Readable(options) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "./node_modules/readable-stream/lib/_stream_duplex.js");
  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 get() {
    if (this._readableState === undefined) {
      return false;
    }

    return this._readableState.destroyed;
  },
  set: function set(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 = __webpack_require__(/*! string_decoder/ */ "./node_modules/string_decoder/lib/string_decoder.js").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 get() {
    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;
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/readable-stream/lib/_stream_transform.js":
/*!***************************************************************!*\
  !*** ./node_modules/readable-stream/lib/_stream_transform.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 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.


module.exports = Transform;

var Duplex = __webpack_require__(/*! ./_stream_duplex */ "./node_modules/readable-stream/lib/_stream_duplex.js");
/*<replacement>*/


var util = Object.create(__webpack_require__(/*! core-util-is */ "./node_modules/core-util-is/lib/util.js"));
util.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
/*</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);
}

/***/ }),

/***/ "./node_modules/readable-stream/lib/_stream_writable.js":
/*!**************************************************************!*\
  !*** ./node_modules/readable-stream/lib/_stream_writable.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(process, setImmediate, 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.
// A bit simpler than readable streams.
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
// the drain event emission and buffering.

/*<replacement>*/

var pna = __webpack_require__(/*! process-nextick-args */ "./node_modules/process-nextick-args/index.js");
/*</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 = Object.create(__webpack_require__(/*! core-util-is */ "./node_modules/core-util-is/lib/util.js"));
util.inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");
/*</replacement>*/

/*<replacement>*/

var internalUtil = {
  deprecate: __webpack_require__(/*! util-deprecate */ "./node_modules/util-deprecate/browser.js")
};
/*</replacement>*/

/*<replacement>*/

var Stream = __webpack_require__(/*! ./internal/streams/stream */ "./node_modules/readable-stream/lib/internal/streams/stream-browser.js");
/*</replacement>*/

/*<replacement>*/


var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").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 = __webpack_require__(/*! ./internal/streams/destroy */ "./node_modules/readable-stream/lib/internal/streams/destroy.js");

util.inherits(Writable, Stream);

function nop() {}

function WritableState(options, stream) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "./node_modules/readable-stream/lib/_stream_duplex.js");
  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 value(object) {
      if (realHasInstance.call(this, object)) return true;
      if (this !== Writable) return false;
      return object && object._writableState instanceof WritableState;
    }
  });
} else {
  realHasInstance = function realHasInstance(object) {
    return object instanceof this;
  };
}

function Writable(options) {
  Duplex = Duplex || __webpack_require__(/*! ./_stream_duplex */ "./node_modules/readable-stream/lib/_stream_duplex.js"); // 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 get() {
    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 get() {
    if (this._writableState === undefined) {
      return false;
    }

    return this._writableState.destroyed;
  },
  set: function set(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);
};
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../process/browser.js */ "./node_modules/process/browser.js"), __webpack_require__(/*! ./../../timers-browserify/main.js */ "./node_modules/timers-browserify/main.js").setImmediate, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/readable-stream/lib/internal/streams/BufferList.js":
/*!*************************************************************************!*\
  !*** ./node_modules/readable-stream/lib/internal/streams/BufferList.js ***!
  \*************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var util = __webpack_require__(/*! util */ 2);

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;
  };
}

/***/ }),

/***/ "./node_modules/readable-stream/lib/internal/streams/destroy.js":
/*!**********************************************************************!*\
  !*** ./node_modules/readable-stream/lib/internal/streams/destroy.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

/*<replacement>*/

var pna = __webpack_require__(/*! process-nextick-args */ "./node_modules/process-nextick-args/index.js");
/*</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
};

/***/ }),

/***/ "./node_modules/readable-stream/lib/internal/streams/stream-browser.js":
/*!*****************************************************************************!*\
  !*** ./node_modules/readable-stream/lib/internal/streams/stream-browser.js ***!
  \*****************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! events */ "./node_modules/events/events.js").EventEmitter;

/***/ }),

/***/ "./node_modules/readable-stream/passthrough.js":
/*!*****************************************************!*\
  !*** ./node_modules/readable-stream/passthrough.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./readable */ "./node_modules/readable-stream/readable-browser.js").PassThrough;

/***/ }),

/***/ "./node_modules/readable-stream/readable-browser.js":
/*!**********************************************************!*\
  !*** ./node_modules/readable-stream/readable-browser.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

exports = module.exports = __webpack_require__(/*! ./lib/_stream_readable.js */ "./node_modules/readable-stream/lib/_stream_readable.js");
exports.Stream = exports;
exports.Readable = exports;
exports.Writable = __webpack_require__(/*! ./lib/_stream_writable.js */ "./node_modules/readable-stream/lib/_stream_writable.js");
exports.Duplex = __webpack_require__(/*! ./lib/_stream_duplex.js */ "./node_modules/readable-stream/lib/_stream_duplex.js");
exports.Transform = __webpack_require__(/*! ./lib/_stream_transform.js */ "./node_modules/readable-stream/lib/_stream_transform.js");
exports.PassThrough = __webpack_require__(/*! ./lib/_stream_passthrough.js */ "./node_modules/readable-stream/lib/_stream_passthrough.js");

/***/ }),

/***/ "./node_modules/readable-stream/transform.js":
/*!***************************************************!*\
  !*** ./node_modules/readable-stream/transform.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./readable */ "./node_modules/readable-stream/readable-browser.js").Transform;

/***/ }),

/***/ "./node_modules/readable-stream/writable-browser.js":
/*!**********************************************************!*\
  !*** ./node_modules/readable-stream/writable-browser.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./lib/_stream_writable.js */ "./node_modules/readable-stream/lib/_stream_writable.js");

/***/ }),

/***/ "./node_modules/ripemd160/index.js":
/*!*****************************************!*\
  !*** ./node_modules/ripemd160/index.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var Buffer = __webpack_require__(/*! buffer */ "./node_modules/node-libs-browser/node_modules/buffer/index.js").Buffer;

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var HashBase = __webpack_require__(/*! hash-base */ "./node_modules/hash-base/index.js");

var ARRAY16 = new Array(16);
var zl = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];
var zr = [5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];
var sl = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6];
var sr = [8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11];
var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e];
var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000];

function RIPEMD160() {
  HashBase.call(this, 64); // state

  this._a = 0x67452301;
  this._b = 0xefcdab89;
  this._c = 0x98badcfe;
  this._d = 0x10325476;
  this._e = 0xc3d2e1f0;
}

inherits(RIPEMD160, HashBase);

RIPEMD160.prototype._update = function () {
  var words = ARRAY16;

  for (var j = 0; j < 16; ++j) {
    words[j] = this._block.readInt32LE(j * 4);
  }

  var al = this._a | 0;
  var bl = this._b | 0;
  var cl = this._c | 0;
  var dl = this._d | 0;
  var el = this._e | 0;
  var ar = this._a | 0;
  var br = this._b | 0;
  var cr = this._c | 0;
  var dr = this._d | 0;
  var er = this._e | 0; // computation

  for (var i = 0; i < 80; i += 1) {
    var tl;
    var tr;

    if (i < 16) {
      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
    } else if (i < 32) {
      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
    } else if (i < 48) {
      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
    } else if (i < 64) {
      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
    } else {
      // if (i<80) {
      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
    }

    al = el;
    el = dl;
    dl = rotl(cl, 10);
    cl = bl;
    bl = tl;
    ar = er;
    er = dr;
    dr = rotl(cr, 10);
    cr = br;
    br = tr;
  } // update state


  var t = this._b + cl + dr | 0;
  this._b = this._c + dl + er | 0;
  this._c = this._d + el + ar | 0;
  this._d = this._e + al + br | 0;
  this._e = this._a + bl + cr | 0;
  this._a = t;
};

RIPEMD160.prototype._digest = function () {
  // create padding and handle blocks
  this._block[this._blockOffset++] = 0x80;

  if (this._blockOffset > 56) {
    this._block.fill(0, this._blockOffset, 64);

    this._update();

    this._blockOffset = 0;
  }

  this._block.fill(0, this._blockOffset, 56);

  this._block.writeUInt32LE(this._length[0], 56);

  this._block.writeUInt32LE(this._length[1], 60);

  this._update(); // produce result


  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20);
  buffer.writeInt32LE(this._a, 0);
  buffer.writeInt32LE(this._b, 4);
  buffer.writeInt32LE(this._c, 8);
  buffer.writeInt32LE(this._d, 12);
  buffer.writeInt32LE(this._e, 16);
  return buffer;
};

function rotl(x, n) {
  return x << n | x >>> 32 - n;
}

function fn1(a, b, c, d, e, m, k, s) {
  return rotl(a + (b ^ c ^ d) + m + k | 0, s) + e | 0;
}

function fn2(a, b, c, d, e, m, k, s) {
  return rotl(a + (b & c | ~b & d) + m + k | 0, s) + e | 0;
}

function fn3(a, b, c, d, e, m, k, s) {
  return rotl(a + ((b | ~c) ^ d) + m + k | 0, s) + e | 0;
}

function fn4(a, b, c, d, e, m, k, s) {
  return rotl(a + (b & d | c & ~d) + m + k | 0, s) + e | 0;
}

function fn5(a, b, c, d, e, m, k, s) {
  return rotl(a + (b ^ (c | ~d)) + m + k | 0, s) + e | 0;
}

module.exports = RIPEMD160;

/***/ }),

/***/ "./node_modules/safe-buffer/index.js":
/*!*******************************************!*\
  !*** ./node_modules/safe-buffer/index.js ***!
  \*******************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* eslint-disable node/no-deprecated-api */
var buffer = __webpack_require__(/*! buffer */ "./node_modules/node-libs-browser/node_modules/buffer/index.js");

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);
};

/***/ }),

/***/ "./node_modules/setimmediate/setImmediate.js":
/*!***************************************************!*\
  !*** ./node_modules/setimmediate/setImmediate.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
  "use strict";

  if (global.setImmediate) {
    return;
  }

  var nextHandle = 1; // Spec says greater than zero

  var tasksByHandle = {};
  var currentlyRunningATask = false;
  var doc = global.document;
  var registerImmediate;

  function setImmediate(callback) {
    // Callback can either be a function or a string
    if (typeof callback !== "function") {
      callback = new Function("" + callback);
    } // Copy function arguments


    var args = new Array(arguments.length - 1);

    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i + 1];
    } // Store and register the task


    var task = {
      callback: callback,
      args: args
    };
    tasksByHandle[nextHandle] = task;
    registerImmediate(nextHandle);
    return nextHandle++;
  }

  function clearImmediate(handle) {
    delete tasksByHandle[handle];
  }

  function run(task) {
    var callback = task.callback;
    var args = task.args;

    switch (args.length) {
      case 0:
        callback();
        break;

      case 1:
        callback(args[0]);
        break;

      case 2:
        callback(args[0], args[1]);
        break;

      case 3:
        callback(args[0], args[1], args[2]);
        break;

      default:
        callback.apply(undefined, args);
        break;
    }
  }

  function runIfPresent(handle) {
    // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
    // So if we're currently running a task, we'll need to delay this invocation.
    if (currentlyRunningATask) {
      // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
      // "too much recursion" error.
      setTimeout(runIfPresent, 0, handle);
    } else {
      var task = tasksByHandle[handle];

      if (task) {
        currentlyRunningATask = true;

        try {
          run(task);
        } finally {
          clearImmediate(handle);
          currentlyRunningATask = false;
        }
      }
    }
  }

  function installNextTickImplementation() {
    registerImmediate = function registerImmediate(handle) {
      process.nextTick(function () {
        runIfPresent(handle);
      });
    };
  }

  function canUsePostMessage() {
    // The test against `importScripts` prevents this implementation from being installed inside a web worker,
    // where `global.postMessage` means something completely different and can't be used for this purpose.
    if (global.postMessage && !global.importScripts) {
      var postMessageIsAsynchronous = true;
      var oldOnMessage = global.onmessage;

      global.onmessage = function () {
        postMessageIsAsynchronous = false;
      };

      global.postMessage("", "*");
      global.onmessage = oldOnMessage;
      return postMessageIsAsynchronous;
    }
  }

  function installPostMessageImplementation() {
    // Installs an event handler on `global` for the `message` event: see
    // * https://developer.mozilla.org/en/DOM/window.postMessage
    // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
    var messagePrefix = "setImmediate$" + Math.random() + "$";

    var onGlobalMessage = function onGlobalMessage(event) {
      if (event.source === global && typeof event.data === "string" && event.data.indexOf(messagePrefix) === 0) {
        runIfPresent(+event.data.slice(messagePrefix.length));
      }
    };

    if (global.addEventListener) {
      global.addEventListener("message", onGlobalMessage, false);
    } else {
      global.attachEvent("onmessage", onGlobalMessage);
    }

    registerImmediate = function registerImmediate(handle) {
      global.postMessage(messagePrefix + handle, "*");
    };
  }

  function installMessageChannelImplementation() {
    var channel = new MessageChannel();

    channel.port1.onmessage = function (event) {
      var handle = event.data;
      runIfPresent(handle);
    };

    registerImmediate = function registerImmediate(handle) {
      channel.port2.postMessage(handle);
    };
  }

  function installReadyStateChangeImplementation() {
    var html = doc.documentElement;

    registerImmediate = function registerImmediate(handle) {
      // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
      // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
      var script = doc.createElement("script");

      script.onreadystatechange = function () {
        runIfPresent(handle);
        script.onreadystatechange = null;
        html.removeChild(script);
        script = null;
      };

      html.appendChild(script);
    };
  }

  function installSetTimeoutImplementation() {
    registerImmediate = function registerImmediate(handle) {
      setTimeout(runIfPresent, 0, handle);
    };
  } // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.


  var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
  attachTo = attachTo && attachTo.setTimeout ? attachTo : global; // Don't get fooled by e.g. browserify environments.

  if ({}.toString.call(global.process) === "[object process]") {
    // For Node.js before 0.9
    installNextTickImplementation();
  } else if (canUsePostMessage()) {
    // For non-IE10 modern browsers
    installPostMessageImplementation();
  } else if (global.MessageChannel) {
    // For web workers, where supported
    installMessageChannelImplementation();
  } else if (doc && "onreadystatechange" in doc.createElement("script")) {
    // For IE 6–8
    installReadyStateChangeImplementation();
  } else {
    // For older browsers
    installSetTimeoutImplementation();
  }

  attachTo.setImmediate = setImmediate;
  attachTo.clearImmediate = clearImmediate;
})(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self);
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"), __webpack_require__(/*! ./../process/browser.js */ "./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/sha.js/hash.js":
/*!*************************************!*\
  !*** ./node_modules/sha.js/hash.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer; // prototype class for hash functions


function Hash(blockSize, finalSize) {
  this._block = Buffer.alloc(blockSize);
  this._finalSize = finalSize;
  this._blockSize = blockSize;
  this._len = 0;
}

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

  var block = this._block;
  var blockSize = this._blockSize;
  var length = data.length;
  var accum = this._len;

  for (var offset = 0; offset < length;) {
    var assigned = accum % blockSize;
    var remainder = Math.min(length - offset, blockSize - assigned);

    for (var i = 0; i < remainder; i++) {
      block[assigned + i] = data[offset + i];
    }

    accum += remainder;
    offset += remainder;

    if (accum % blockSize === 0) {
      this._update(block);
    }
  }

  this._len += length;
  return this;
};

Hash.prototype.digest = function (enc) {
  var rem = this._len % this._blockSize;
  this._block[rem] = 0x80; // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize

  this._block.fill(0, rem + 1);

  if (rem >= this._finalSize) {
    this._update(this._block);

    this._block.fill(0);
  }

  var bits = this._len * 8; // uint32

  if (bits <= 0xffffffff) {
    this._block.writeUInt32BE(bits, this._blockSize - 4); // uint64

  } else {
    var lowBits = (bits & 0xffffffff) >>> 0;
    var highBits = (bits - lowBits) / 0x100000000;

    this._block.writeUInt32BE(highBits, this._blockSize - 8);

    this._block.writeUInt32BE(lowBits, this._blockSize - 4);
  }

  this._update(this._block);

  var hash = this._hash();

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

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

module.exports = Hash;

/***/ }),

/***/ "./node_modules/sha.js/index.js":
/*!**************************************!*\
  !*** ./node_modules/sha.js/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

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

exports.sha = __webpack_require__(/*! ./sha */ "./node_modules/sha.js/sha.js");
exports.sha1 = __webpack_require__(/*! ./sha1 */ "./node_modules/sha.js/sha1.js");
exports.sha224 = __webpack_require__(/*! ./sha224 */ "./node_modules/sha.js/sha224.js");
exports.sha256 = __webpack_require__(/*! ./sha256 */ "./node_modules/sha.js/sha256.js");
exports.sha384 = __webpack_require__(/*! ./sha384 */ "./node_modules/sha.js/sha384.js");
exports.sha512 = __webpack_require__(/*! ./sha512 */ "./node_modules/sha.js/sha512.js");

/***/ }),

/***/ "./node_modules/sha.js/sha.js":
/*!************************************!*\
  !*** ./node_modules/sha.js/sha.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/*
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
 * in FIPS PUB 180-1
 * This source code is derived from sha1.js of the same repository.
 * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
 * operation was added.
 */
var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0];
var W = new Array(80);

function Sha() {
  this.init();
  this._w = W;
  Hash.call(this, 64, 56);
}

inherits(Sha, Hash);

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

function rotl5(num) {
  return num << 5 | num >>> 27;
}

function rotl30(num) {
  return num << 30 | num >>> 2;
}

function ft(s, b, c, d) {
  if (s === 0) return b & c | ~b & d;
  if (s === 2) return b & c | b & d | c & d;
  return b ^ c ^ d;
}

Sha.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;

  for (var i = 0; i < 16; ++i) {
    W[i] = M.readInt32BE(i * 4);
  }

  for (; i < 80; ++i) {
    W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
  }

  for (var j = 0; j < 80; ++j) {
    var s = ~~(j / 20);
    var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
    e = d;
    d = c;
    c = rotl30(b);
    b = a;
    a = t;
  }

  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
};

Sha.prototype._hash = function () {
  var H = Buffer.allocUnsafe(20);
  H.writeInt32BE(this._a | 0, 0);
  H.writeInt32BE(this._b | 0, 4);
  H.writeInt32BE(this._c | 0, 8);
  H.writeInt32BE(this._d | 0, 12);
  H.writeInt32BE(this._e | 0, 16);
  return H;
};

module.exports = Sha;

/***/ }),

/***/ "./node_modules/sha.js/sha1.js":
/*!*************************************!*\
  !*** ./node_modules/sha.js/sha1.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

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

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0];
var W = new Array(80);

function Sha1() {
  this.init();
  this._w = W;
  Hash.call(this, 64, 56);
}

inherits(Sha1, Hash);

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

function rotl1(num) {
  return num << 1 | num >>> 31;
}

function rotl5(num) {
  return num << 5 | num >>> 27;
}

function rotl30(num) {
  return num << 30 | num >>> 2;
}

function ft(s, b, c, d) {
  if (s === 0) return b & c | ~b & d;
  if (s === 2) return b & c | b & d | c & d;
  return b ^ c ^ d;
}

Sha1.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;

  for (var i = 0; i < 16; ++i) {
    W[i] = M.readInt32BE(i * 4);
  }

  for (; i < 80; ++i) {
    W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
  }

  for (var j = 0; j < 80; ++j) {
    var s = ~~(j / 20);
    var t = rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s] | 0;
    e = d;
    d = c;
    c = rotl30(b);
    b = a;
    a = t;
  }

  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
};

Sha1.prototype._hash = function () {
  var H = Buffer.allocUnsafe(20);
  H.writeInt32BE(this._a | 0, 0);
  H.writeInt32BE(this._b | 0, 4);
  H.writeInt32BE(this._c | 0, 8);
  H.writeInt32BE(this._d | 0, 12);
  H.writeInt32BE(this._e | 0, 16);
  return H;
};

module.exports = Sha1;

/***/ }),

/***/ "./node_modules/sha.js/sha224.js":
/*!***************************************!*\
  !*** ./node_modules/sha.js/sha224.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
 * in FIPS 180-2
 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 *
 */
var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Sha256 = __webpack_require__(/*! ./sha256 */ "./node_modules/sha.js/sha256.js");

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var W = new Array(64);

function Sha224() {
  this.init();
  this._w = W; // new Array(64)

  Hash.call(this, 64, 56);
}

inherits(Sha224, Sha256);

Sha224.prototype.init = function () {
  this._a = 0xc1059ed8;
  this._b = 0x367cd507;
  this._c = 0x3070dd17;
  this._d = 0xf70e5939;
  this._e = 0xffc00b31;
  this._f = 0x68581511;
  this._g = 0x64f98fa7;
  this._h = 0xbefa4fa4;
  return this;
};

Sha224.prototype._hash = function () {
  var H = Buffer.allocUnsafe(28);
  H.writeInt32BE(this._a, 0);
  H.writeInt32BE(this._b, 4);
  H.writeInt32BE(this._c, 8);
  H.writeInt32BE(this._d, 12);
  H.writeInt32BE(this._e, 16);
  H.writeInt32BE(this._f, 20);
  H.writeInt32BE(this._g, 24);
  return H;
};

module.exports = Sha224;

/***/ }),

/***/ "./node_modules/sha.js/sha256.js":
/*!***************************************!*\
  !*** ./node_modules/sha.js/sha256.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/**
 * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
 * in FIPS 180-2
 * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 *
 */
var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var K = [0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2];
var W = new Array(64);

function Sha256() {
  this.init();
  this._w = W; // new Array(64)

  Hash.call(this, 64, 56);
}

inherits(Sha256, Hash);

Sha256.prototype.init = function () {
  this._a = 0x6a09e667;
  this._b = 0xbb67ae85;
  this._c = 0x3c6ef372;
  this._d = 0xa54ff53a;
  this._e = 0x510e527f;
  this._f = 0x9b05688c;
  this._g = 0x1f83d9ab;
  this._h = 0x5be0cd19;
  return this;
};

function ch(x, y, z) {
  return z ^ x & (y ^ z);
}

function maj(x, y, z) {
  return x & y | z & (x | y);
}

function sigma0(x) {
  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
}

function sigma1(x) {
  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
}

function gamma0(x) {
  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
}

function gamma1(x) {
  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
}

Sha256.prototype._update = function (M) {
  var W = this._w;
  var a = this._a | 0;
  var b = this._b | 0;
  var c = this._c | 0;
  var d = this._d | 0;
  var e = this._e | 0;
  var f = this._f | 0;
  var g = this._g | 0;
  var h = this._h | 0;

  for (var i = 0; i < 16; ++i) {
    W[i] = M.readInt32BE(i * 4);
  }

  for (; i < 64; ++i) {
    W[i] = gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16] | 0;
  }

  for (var j = 0; j < 64; ++j) {
    var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W[j] | 0;
    var T2 = sigma0(a) + maj(a, b, c) | 0;
    h = g;
    g = f;
    f = e;
    e = d + T1 | 0;
    d = c;
    c = b;
    b = a;
    a = T1 + T2 | 0;
  }

  this._a = a + this._a | 0;
  this._b = b + this._b | 0;
  this._c = c + this._c | 0;
  this._d = d + this._d | 0;
  this._e = e + this._e | 0;
  this._f = f + this._f | 0;
  this._g = g + this._g | 0;
  this._h = h + this._h | 0;
};

Sha256.prototype._hash = function () {
  var H = Buffer.allocUnsafe(32);
  H.writeInt32BE(this._a, 0);
  H.writeInt32BE(this._b, 4);
  H.writeInt32BE(this._c, 8);
  H.writeInt32BE(this._d, 12);
  H.writeInt32BE(this._e, 16);
  H.writeInt32BE(this._f, 20);
  H.writeInt32BE(this._g, 24);
  H.writeInt32BE(this._h, 28);
  return H;
};

module.exports = Sha256;

/***/ }),

/***/ "./node_modules/sha.js/sha384.js":
/*!***************************************!*\
  !*** ./node_modules/sha.js/sha384.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var SHA512 = __webpack_require__(/*! ./sha512 */ "./node_modules/sha.js/sha512.js");

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var W = new Array(160);

function Sha384() {
  this.init();
  this._w = W;
  Hash.call(this, 128, 112);
}

inherits(Sha384, SHA512);

Sha384.prototype.init = function () {
  this._ah = 0xcbbb9d5d;
  this._bh = 0x629a292a;
  this._ch = 0x9159015a;
  this._dh = 0x152fecd8;
  this._eh = 0x67332667;
  this._fh = 0x8eb44a87;
  this._gh = 0xdb0c2e0d;
  this._hh = 0x47b5481d;
  this._al = 0xc1059ed8;
  this._bl = 0x367cd507;
  this._cl = 0x3070dd17;
  this._dl = 0xf70e5939;
  this._el = 0xffc00b31;
  this._fl = 0x68581511;
  this._gl = 0x64f98fa7;
  this._hl = 0xbefa4fa4;
  return this;
};

Sha384.prototype._hash = function () {
  var H = Buffer.allocUnsafe(48);

  function writeInt64BE(h, l, offset) {
    H.writeInt32BE(h, offset);
    H.writeInt32BE(l, offset + 4);
  }

  writeInt64BE(this._ah, this._al, 0);
  writeInt64BE(this._bh, this._bl, 8);
  writeInt64BE(this._ch, this._cl, 16);
  writeInt64BE(this._dh, this._dl, 24);
  writeInt64BE(this._eh, this._el, 32);
  writeInt64BE(this._fh, this._fl, 40);
  return H;
};

module.exports = Sha384;

/***/ }),

/***/ "./node_modules/sha.js/sha512.js":
/*!***************************************!*\
  !*** ./node_modules/sha.js/sha512.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

var Hash = __webpack_require__(/*! ./hash */ "./node_modules/sha.js/hash.js");

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").Buffer;

var K = [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817];
var W = new Array(160);

function Sha512() {
  this.init();
  this._w = W;
  Hash.call(this, 128, 112);
}

inherits(Sha512, Hash);

Sha512.prototype.init = function () {
  this._ah = 0x6a09e667;
  this._bh = 0xbb67ae85;
  this._ch = 0x3c6ef372;
  this._dh = 0xa54ff53a;
  this._eh = 0x510e527f;
  this._fh = 0x9b05688c;
  this._gh = 0x1f83d9ab;
  this._hh = 0x5be0cd19;
  this._al = 0xf3bcc908;
  this._bl = 0x84caa73b;
  this._cl = 0xfe94f82b;
  this._dl = 0x5f1d36f1;
  this._el = 0xade682d1;
  this._fl = 0x2b3e6c1f;
  this._gl = 0xfb41bd6b;
  this._hl = 0x137e2179;
  return this;
};

function Ch(x, y, z) {
  return z ^ x & (y ^ z);
}

function maj(x, y, z) {
  return x & y | z & (x | y);
}

function sigma0(x, xl) {
  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25);
}

function sigma1(x, xl) {
  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23);
}

function Gamma0(x, xl) {
  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7;
}

function Gamma0l(x, xl) {
  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25);
}

function Gamma1(x, xl) {
  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6;
}

function Gamma1l(x, xl) {
  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26);
}

function getCarry(a, b) {
  return a >>> 0 < b >>> 0 ? 1 : 0;
}

Sha512.prototype._update = function (M) {
  var W = this._w;
  var ah = this._ah | 0;
  var bh = this._bh | 0;
  var ch = this._ch | 0;
  var dh = this._dh | 0;
  var eh = this._eh | 0;
  var fh = this._fh | 0;
  var gh = this._gh | 0;
  var hh = this._hh | 0;
  var al = this._al | 0;
  var bl = this._bl | 0;
  var cl = this._cl | 0;
  var dl = this._dl | 0;
  var el = this._el | 0;
  var fl = this._fl | 0;
  var gl = this._gl | 0;
  var hl = this._hl | 0;

  for (var i = 0; i < 32; i += 2) {
    W[i] = M.readInt32BE(i * 4);
    W[i + 1] = M.readInt32BE(i * 4 + 4);
  }

  for (; i < 160; i += 2) {
    var xh = W[i - 15 * 2];
    var xl = W[i - 15 * 2 + 1];
    var gamma0 = Gamma0(xh, xl);
    var gamma0l = Gamma0l(xl, xh);
    xh = W[i - 2 * 2];
    xl = W[i - 2 * 2 + 1];
    var gamma1 = Gamma1(xh, xl);
    var gamma1l = Gamma1l(xl, xh); // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]

    var Wi7h = W[i - 7 * 2];
    var Wi7l = W[i - 7 * 2 + 1];
    var Wi16h = W[i - 16 * 2];
    var Wi16l = W[i - 16 * 2 + 1];
    var Wil = gamma0l + Wi7l | 0;
    var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0;
    Wil = Wil + gamma1l | 0;
    Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0;
    Wil = Wil + Wi16l | 0;
    Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
    W[i] = Wih;
    W[i + 1] = Wil;
  }

  for (var j = 0; j < 160; j += 2) {
    Wih = W[j];
    Wil = W[j + 1];
    var majh = maj(ah, bh, ch);
    var majl = maj(al, bl, cl);
    var sigma0h = sigma0(ah, al);
    var sigma0l = sigma0(al, ah);
    var sigma1h = sigma1(eh, el);
    var sigma1l = sigma1(el, eh); // t1 = h + sigma1 + ch + K[j] + W[j]

    var Kih = K[j];
    var Kil = K[j + 1];
    var chh = Ch(eh, fh, gh);
    var chl = Ch(el, fl, gl);
    var t1l = hl + sigma1l | 0;
    var t1h = hh + sigma1h + getCarry(t1l, hl) | 0;
    t1l = t1l + chl | 0;
    t1h = t1h + chh + getCarry(t1l, chl) | 0;
    t1l = t1l + Kil | 0;
    t1h = t1h + Kih + getCarry(t1l, Kil) | 0;
    t1l = t1l + Wil | 0;
    t1h = t1h + Wih + getCarry(t1l, Wil) | 0; // t2 = sigma0 + maj

    var t2l = sigma0l + majl | 0;
    var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0;
    hh = gh;
    hl = gl;
    gh = fh;
    gl = fl;
    fh = eh;
    fl = el;
    el = dl + t1l | 0;
    eh = dh + t1h + getCarry(el, dl) | 0;
    dh = ch;
    dl = cl;
    ch = bh;
    cl = bl;
    bh = ah;
    bl = al;
    al = t1l + t2l | 0;
    ah = t1h + t2h + getCarry(al, t1l) | 0;
  }

  this._al = this._al + al | 0;
  this._bl = this._bl + bl | 0;
  this._cl = this._cl + cl | 0;
  this._dl = this._dl + dl | 0;
  this._el = this._el + el | 0;
  this._fl = this._fl + fl | 0;
  this._gl = this._gl + gl | 0;
  this._hl = this._hl + hl | 0;
  this._ah = this._ah + ah + getCarry(this._al, al) | 0;
  this._bh = this._bh + bh + getCarry(this._bl, bl) | 0;
  this._ch = this._ch + ch + getCarry(this._cl, cl) | 0;
  this._dh = this._dh + dh + getCarry(this._dl, dl) | 0;
  this._eh = this._eh + eh + getCarry(this._el, el) | 0;
  this._fh = this._fh + fh + getCarry(this._fl, fl) | 0;
  this._gh = this._gh + gh + getCarry(this._gl, gl) | 0;
  this._hh = this._hh + hh + getCarry(this._hl, hl) | 0;
};

Sha512.prototype._hash = function () {
  var H = Buffer.allocUnsafe(64);

  function writeInt64BE(h, l, offset) {
    H.writeInt32BE(h, offset);
    H.writeInt32BE(l, offset + 4);
  }

  writeInt64BE(this._ah, this._al, 0);
  writeInt64BE(this._bh, this._bl, 8);
  writeInt64BE(this._ch, this._cl, 16);
  writeInt64BE(this._dh, this._dl, 24);
  writeInt64BE(this._eh, this._el, 32);
  writeInt64BE(this._fh, this._fl, 40);
  writeInt64BE(this._gh, this._gl, 48);
  writeInt64BE(this._hh, this._hl, 56);
  return H;
};

module.exports = Sha512;

/***/ }),

/***/ "./node_modules/stream-browserify/index.js":
/*!*************************************************!*\
  !*** ./node_modules/stream-browserify/index.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 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.
module.exports = Stream;

var EE = __webpack_require__(/*! events */ "./node_modules/events/events.js").EventEmitter;

var inherits = __webpack_require__(/*! inherits */ "./node_modules/inherits/inherits_browser.js");

inherits(Stream, EE);
Stream.Readable = __webpack_require__(/*! readable-stream/readable.js */ "./node_modules/readable-stream/readable-browser.js");
Stream.Writable = __webpack_require__(/*! readable-stream/writable.js */ "./node_modules/readable-stream/writable-browser.js");
Stream.Duplex = __webpack_require__(/*! readable-stream/duplex.js */ "./node_modules/readable-stream/duplex-browser.js");
Stream.Transform = __webpack_require__(/*! readable-stream/transform.js */ "./node_modules/readable-stream/transform.js");
Stream.PassThrough = __webpack_require__(/*! readable-stream/passthrough.js */ "./node_modules/readable-stream/passthrough.js"); // Backwards-compat with node 0.4.x

Stream.Stream = Stream; // old-style streams.  Note that the pipe method (the only relevant
// part of this class) is overridden in the Readable class.

function Stream() {
  EE.call(this);
}

Stream.prototype.pipe = function (dest, options) {
  var source = this;

  function ondata(chunk) {
    if (dest.writable) {
      if (false === dest.write(chunk) && source.pause) {
        source.pause();
      }
    }
  }

  source.on('data', ondata);

  function ondrain() {
    if (source.readable && source.resume) {
      source.resume();
    }
  }

  dest.on('drain', ondrain); // If the 'end' option is not supplied, dest.end() will be called when
  // source gets the 'end' or 'close' events.  Only dest.end() once.

  if (!dest._isStdio && (!options || options.end !== false)) {
    source.on('end', onend);
    source.on('close', onclose);
  }

  var didOnEnd = false;

  function onend() {
    if (didOnEnd) return;
    didOnEnd = true;
    dest.end();
  }

  function onclose() {
    if (didOnEnd) return;
    didOnEnd = true;
    if (typeof dest.destroy === 'function') dest.destroy();
  } // don't leave dangling pipes when there are errors.


  function onerror(er) {
    cleanup();

    if (EE.listenerCount(this, 'error') === 0) {
      throw er; // Unhandled stream error in pipe.
    }
  }

  source.on('error', onerror);
  dest.on('error', onerror); // remove all the event listeners that were added.

  function cleanup() {
    source.removeListener('data', ondata);
    dest.removeListener('drain', ondrain);
    source.removeListener('end', onend);
    source.removeListener('close', onclose);
    source.removeListener('error', onerror);
    dest.removeListener('error', onerror);
    source.removeListener('end', cleanup);
    source.removeListener('close', cleanup);
    dest.removeListener('close', cleanup);
  }

  source.on('end', cleanup);
  source.on('close', cleanup);
  dest.on('close', cleanup);
  dest.emit('pipe', source); // Allow for unix-like usage: A.pipe(B).pipe(C)

  return dest;
};

/***/ }),

/***/ "./node_modules/string_decoder/lib/string_decoder.js":
/*!***********************************************************!*\
  !*** ./node_modules/string_decoder/lib/string_decoder.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 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.

/*<replacement>*/

var Buffer = __webpack_require__(/*! safe-buffer */ "./node_modules/safe-buffer/index.js").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) : '';
}

/***/ }),

/***/ "./node_modules/timers-browserify/main.js":
/*!************************************************!*\
  !*** ./node_modules/timers-browserify/main.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {var scope = typeof global !== "undefined" && global || typeof self !== "undefined" && self || window;
var apply = Function.prototype.apply; // DOM APIs, for completeness

exports.setTimeout = function () {
  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
};

exports.setInterval = function () {
  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
};

exports.clearTimeout = exports.clearInterval = function (timeout) {
  if (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(scope, 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);
  }
}; // setimmediate attaches itself to the global object


__webpack_require__(/*! setimmediate */ "./node_modules/setimmediate/setImmediate.js"); // On some exotic environments, it's not clear which object `setimmediate` was
// able to install onto.  Search each possibility in the same order as the
// `setimmediate` library.


exports.setImmediate = typeof self !== "undefined" && self.setImmediate || typeof global !== "undefined" && global.setImmediate || this && this.setImmediate;
exports.clearImmediate = typeof self !== "undefined" && self.clearImmediate || typeof global !== "undefined" && global.clearImmediate || this && this.clearImmediate;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/util-deprecate/browser.js":
/*!************************************************!*\
  !*** ./node_modules/util-deprecate/browser.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(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';
}
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/vm-browserify/index.js":
/*!*********************************************!*\
  !*** ./node_modules/vm-browserify/index.js ***!
  \*********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var indexOf = function indexOf(xs, item) {
  if (xs.indexOf) return xs.indexOf(item);else for (var i = 0; i < xs.length; i++) {
    if (xs[i] === item) return i;
  }
  return -1;
};

var Object_keys = function Object_keys(obj) {
  if (Object.keys) return Object.keys(obj);else {
    var res = [];

    for (var key in obj) {
      res.push(key);
    }

    return res;
  }
};

var forEach = function forEach(xs, fn) {
  if (xs.forEach) return xs.forEach(fn);else for (var i = 0; i < xs.length; i++) {
    fn(xs[i], i, xs);
  }
};

var defineProp = function () {
  try {
    Object.defineProperty({}, '_', {});
    return function (obj, name, value) {
      Object.defineProperty(obj, name, {
        writable: true,
        enumerable: false,
        configurable: true,
        value: value
      });
    };
  } catch (e) {
    return function (obj, name, value) {
      obj[name] = value;
    };
  }
}();

var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function', 'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError', 'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];

function Context() {}

Context.prototype = {};

var Script = exports.Script = function NodeScript(code) {
  if (!(this instanceof Script)) return new Script(code);
  this.code = code;
};

Script.prototype.runInContext = function (context) {
  if (!(context instanceof Context)) {
    throw new TypeError("needs a 'context' argument.");
  }

  var iframe = document.createElement('iframe');
  if (!iframe.style) iframe.style = {};
  iframe.style.display = 'none';
  document.body.appendChild(iframe);
  var win = iframe.contentWindow;
  var wEval = win.eval,
      wExecScript = win.execScript;

  if (!wEval && wExecScript) {
    // win.eval() magically appears when this is called in IE:
    wExecScript.call(win, 'null');
    wEval = win.eval;
  }

  forEach(Object_keys(context), function (key) {
    win[key] = context[key];
  });
  forEach(globals, function (key) {
    if (context[key]) {
      win[key] = context[key];
    }
  });
  var winKeys = Object_keys(win);
  var res = wEval.call(win, this.code);
  forEach(Object_keys(win), function (key) {
    // Avoid copying circular objects like `top` and `window` by only
    // updating existing context properties or new properties in the `win`
    // that was only introduced after the eval.
    if (key in context || indexOf(winKeys, key) === -1) {
      context[key] = win[key];
    }
  });
  forEach(globals, function (key) {
    if (!(key in context)) {
      defineProp(context, key, win[key]);
    }
  });
  document.body.removeChild(iframe);
  return res;
};

Script.prototype.runInThisContext = function () {
  return eval(this.code); // maybe...
};

Script.prototype.runInNewContext = function (context) {
  var ctx = Script.createContext(context);
  var res = this.runInContext(ctx);

  if (context) {
    forEach(Object_keys(ctx), function (key) {
      context[key] = ctx[key];
    });
  }

  return res;
};

forEach(Object_keys(Script.prototype), function (name) {
  exports[name] = Script[name] = function (code) {
    var s = Script(code);
    return s[name].apply(s, [].slice.call(arguments, 1));
  };
});

exports.isContext = function (context) {
  return context instanceof Context;
};

exports.createScript = function (code) {
  return exports.Script(code);
};

exports.createContext = Script.createContext = function (context) {
  var copy = new Context();

  if (_typeof(context) === 'object') {
    forEach(Object_keys(context), function (key) {
      copy[key] = context[key];
    });
  }

  return copy;
};

/***/ })

}]);
//# sourceMappingURL=vendors~libsodium.bundle.js.map