{"version":3,"sources":["webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/browser/verify.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/state.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/browser/index.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/readable-browser.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_writable.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_duplex.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/algos.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_readable.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_transform.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/errors-browser.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/bn.js/lib/bn.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:////home/runner/work/frontend-monorepo/frontend-monorepo/node_modules/browserify-sign/browser/sign.js"],"names":["Buffer","BN","EC","ec","parseKeys","curves","checkValue","b","q","cmpn","Error","cmp","module","exports","sig","hash","key","signType","tag","pub","type","curveId","data","algorithm","curve","join","pubkey","subjectPrivateKey","verify","ecVerify","p","g","y","pub_key","unpacked","signature","decode","s","r","montp","mont","w","invm","toRed","redPow","mul","mod","fromRed","dsaVerify","concat","len","modulus","byteLength","pad","padNum","length","push","i","from","red","publicExponent","toArray","out","Math","min","ERR_INVALID_OPT_VALUE","codes","getHighWaterMark","state","options","duplexKey","isDuplex","hwm","highWaterMark","highWaterMarkFrom","isFinite","floor","objectMode","createHash","stream","inherits","sign","algorithms","Sign","Writable","call","this","_hashType","_hash","_tag","id","_signType","Verify","createSign","createVerify","Object","keys","forEach","toLowerCase","prototype","_write","_","done","update","enc","end","digest","toString","sigBuffer","Stream","Readable","Duplex","Transform","PassThrough","finished","pipeline","_Object$setPrototypeO","_defineProperty","obj","value","arg","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","String","Number","_toPrimitive","_toPropertyKey","defineProperty","enumerable","configurable","writable","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","resolve","read","onReadable","process","nextTick","AsyncIteratorPrototype","getPrototypeOf","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","next","_this","error","Promise","reject","destroyed","promise","lastPromise","then","wrapForNext","asyncIterator","_this2","destroy","err","_Object$create","iterator","create","_readableState","endEmitted","code","on","bind","_transform","chunk","encoding","cb","CorkedRequest","entry","finish","corkReq","callback","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","OurUint8Array","global","window","self","Uint8Array","realHasInstance","destroyImpl","_require$codes","ERR_INVALID_ARG_TYPE","ERR_METHOD_NOT_IMPLEMENTED","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","errorOrDestroy","nop","writableObjectMode","finalCalled","needDrain","ending","ended","noDecode","decodeStrings","defaultEncoding","writing","corked","sync","bufferProcessing","onwrite","er","_writableState","writecb","writelen","onwriteStateUpdate","finishMaybe","errorEmitted","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","emitClose","autoDestroy","bufferedRequestCount","write","writev","_writev","_destroy","final","_final","doWrite","emit","onwriteDrain","l","buffer","Array","holder","count","allBuffers","isBuf","callFinal","need","prefinish","rState","getBuffer","current","get","hasInstance","Function","object","pipe","ret","isBuffer","_uint8ArrayToBuffer","writeAfterEnd","validChunk","newChunk","decodeChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","indexOf","once","endWritable","set","_undestroy","undestroy","objectKeys","v","method","allowHalfOpen","readable","onend","onEndNT","EventEmitter","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","apply","_objectSpread","target","arguments","source","getOwnPropertyDescriptors","defineProperties","_defineProperties","props","descriptor","inspect","custom","BufferList","instance","Constructor","_classCallCheck","head","tail","protoProps","staticProps","n","alloc","src","offset","allocUnsafe","copy","hasStrings","slice","shift","_getString","_getBuffer","c","str","nb","buf","depth","customInspect","ReadableState","EElistenerCount","emitter","listeners","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","ERR_STREAM_PUSH_AFTER_EOF","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","kProxyEvents","readableObjectMode","pipes","pipesCount","flowing","reading","needReadable","emittedReadable","readableListening","resumeScheduled","paused","awaitDrain","readingMore","decoder","_read","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","chunkInvalid","addChunk","maybeReadMore","unshift","isPaused","setEncoding","content","clear","howMuchToRead","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","listenerCount","resume","nReadingNextTick","resume_","fromList","first","consume","endReadable","endReadableNT","wState","xs","x","parseInt","nOrig","doRead","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","removeListener","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","pipeOnDrain","pause","event","fn","prependListener","_events","isArray","dests","index","splice","ev","addListener","removeAllListeners","wrap","_fromList","iterable","opts","ERR_STREAM_PREMATURE_CLOSE","noop","eos","called","_len","args","_key","onlegacyfinish","writableEnded","readableEnded","onrequest","req","setHeader","abort","isRequest","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","flush","_flush","err2","createErrorType","message","Base","NodeError","_Base","subClass","superClass","arg1","arg2","arg3","getMessage","constructor","__proto__","name","oneOf","expected","thing","map","actual","determiner","search","pos","msg","substr","replace","this_len","substring","endsWith","start","includes","assert","val","ctor","superCtor","super_","TempCtor","number","base","endian","isBN","negative","words","_init","wordSize","e","parseHex4Bits","string","charCodeAt","parseHexByte","lowerBound","parseBase","move","num","max","left","right","_initNumber","_initArray","_parseHex","_parseBase","ceil","j","off","_strip","limbLen","limbPow","total","word","imuln","_iaddn","pow","_move","clone","_expand","size","_normSign","for","zeros","groupSizes","groupBases","padding","carry","groupSize","groupBase","isZero","modrn","idivn","toNumber","toJSON","toBuffer","toArrayLike","smallMulTo","a","lo","k","ncarry","rword","maxJ","ArrayType","reqLength","allocate","_toArrayLikeLE","position","_toArrayLikeBE","clz32","_countBits","t","_zeroBits","bitLength","hi","zeroBits","toTwos","width","abs","inotn","iaddn","fromTwos","testn","notn","ineg","isNeg","neg","iuor","ior","or","uor","iuand","iand","and","uand","iuxor","ixor","xor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","add","sub","comb10MulTo","mid","o","a0","al0","ah0","a1","al1","ah1","a2","al2","ah2","a3","al3","ah3","a4","al4","ah4","a5","al5","ah5","a6","al6","ah6","a7","al7","ah7","a8","al8","ah8","a9","al9","ah9","b0","bl0","bh0","b1","bl1","bh1","b2","bl2","bh2","b3","bl3","bh3","b4","bl4","bh4","b5","bl5","bh5","b6","bl6","bh6","b7","bl7","bh7","b8","bl8","bh8","b9","bl9","bh9","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","bigMulTo","hncarry","jumboMulTo","FFTM","mulTo","makeRBT","N","revBin","rb","permute","rbt","rws","iws","rtws","itws","rtwdf","cos","PI","itwdf","sin","rtwdf_","itwdf_","re","ie","ro","io","rx","guessLen13b","m","odd","conjugate","normalize13b","ws","round","convert13b","stub","ph","mulp","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","isNegNum","muln","sqr","isqr","toBitArray","iushln","bits","carryMask","newCarry","ishln","iushrn","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","div","divmod","positive","divn","umod","divRound","dm","half","r2","andln","acc","modn","egcd","A","B","C","D","isEven","yp","xp","im","isOdd","jm","gcd","_invmp","x1","x2","delta","bincn","ucmp","gtn","gt","gten","gte","ltn","lt","lten","lte","eqn","eq","Red","ctx","convertTo","_forceRed","convertFrom","forceRed","redAdd","redIAdd","redSub","redISub","redShl","shl","redMul","_verify2","redIMul","redSqr","_verify1","redISqr","redSqrt","sqrt","redInvm","redNeg","primes","k256","p224","p192","p25519","MPrime","tmp","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","split","imulK","strip","output","outLen","prev","mod3","one","nOne","lpow","z","inv","wnd","currentLen","u","ERR_MISSING_ARGS","destroyer","closed","to","popCallback","streams","pop","destroys","reduce","createHmac","crt","getKey","algo","hlen","hbits","bits2int","bits2octets","fill","obits","makeKey","kv","makeR","hashType","priv","keyFromPrivate","privateKey","toDER","ecSign","params","priv_key","H","dsaSign"],"mappings":"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","file":"npm.browserify-sign.842b1dd8afdc299380c0.chunk.js","sourcesContent":["'use strict';\n\n// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer;\nvar BN = require('bn.js');\nvar EC = require('elliptic').ec;\nvar parseKeys = require('parse-asn1');\nvar curves = require('./curves.json');\n\nfunction verify(sig, hash, key, signType, tag) {\n  var pub = parseKeys(key);\n  if (pub.type === 'ec') {\n    // rsa keys can be interpreted as ecdsa ones in openssl\n    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') { throw new Error('wrong public key type'); }\n    return ecVerify(sig, hash, pub);\n  } else if (pub.type === 'dsa') {\n    if (signType !== 'dsa') { throw new Error('wrong public key type'); }\n    return dsaVerify(sig, hash, pub);\n  }\n  if (signType !== 'rsa' && signType !== 'ecdsa/rsa') { throw new Error('wrong public key type'); }\n\n  hash = Buffer.concat([tag, hash]);\n  var len = pub.modulus.byteLength();\n  var pad = [1];\n  var padNum = 0;\n  while (hash.length + pad.length + 2 < len) {\n    pad.push(0xff);\n    padNum += 1;\n  }\n  pad.push(0x00);\n  var i = -1;\n  while (++i < hash.length) {\n    pad.push(hash[i]);\n  }\n  pad = Buffer.from(pad);\n  var red = BN.mont(pub.modulus);\n  sig = new BN(sig).toRed(red);\n\n  sig = sig.redPow(new BN(pub.publicExponent));\n  sig = Buffer.from(sig.fromRed().toArray());\n  var out = padNum < 8 ? 1 : 0;\n  len = Math.min(sig.length, pad.length);\n  if (sig.length !== pad.length) { out = 1; }\n\n  i = -1;\n  while (++i < len) { out |= sig[i] ^ pad[i]; }\n  return out === 0;\n}\n\nfunction ecVerify(sig, hash, pub) {\n  var curveId = curves[pub.data.algorithm.curve.join('.')];\n  if (!curveId) { throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.')); }\n\n  var curve = new EC(curveId);\n  var pubkey = pub.data.subjectPrivateKey.data;\n\n  return curve.verify(hash, sig, pubkey);\n}\n\nfunction dsaVerify(sig, hash, pub) {\n  var p = pub.data.p;\n  var q = pub.data.q;\n  var g = pub.data.g;\n  var y = pub.data.pub_key;\n  var unpacked = parseKeys.signature.decode(sig, 'der');\n  var s = unpacked.s;\n  var r = unpacked.r;\n  checkValue(s, q);\n  checkValue(r, q);\n  var montp = BN.mont(p);\n  var w = s.invm(q);\n  var v = g.toRed(montp)\n    .redPow(new BN(hash).mul(w).mod(q))\n    .fromRed()\n    .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())\n    .mod(p)\n    .mod(q);\n  return v.cmp(r) === 0;\n}\n\nfunction checkValue(b, q) {\n  if (b.cmpn(0) <= 0) { throw new Error('invalid sig'); }\n  if (b.cmp(q) >= 0) { throw new Error('invalid sig'); }\n}\n\nmodule.exports = verify;\n","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n    return Math.floor(hwm);\n  }\n\n  // Default value\n  return state.objectMode ? 16 : 16 * 1024;\n}\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","'use strict';\n\nvar Buffer = require('safe-buffer').Buffer;\nvar createHash = require('create-hash');\nvar stream = require('readable-stream');\nvar inherits = require('inherits');\nvar sign = require('./sign');\nvar verify = require('./verify');\n\nvar algorithms = require('./algorithms.json');\nObject.keys(algorithms).forEach(function (key) {\n  algorithms[key].id = Buffer.from(algorithms[key].id, 'hex');\n  algorithms[key.toLowerCase()] = algorithms[key];\n});\n\nfunction Sign(algorithm) {\n  stream.Writable.call(this);\n\n  var data = algorithms[algorithm];\n  if (!data) { throw new Error('Unknown message digest'); }\n\n  this._hashType = data.hash;\n  this._hash = createHash(data.hash);\n  this._tag = data.id;\n  this._signType = data.sign;\n}\ninherits(Sign, stream.Writable);\n\nSign.prototype._write = function _write(data, _, done) {\n  this._hash.update(data);\n  done();\n};\n\nSign.prototype.update = function update(data, enc) {\n  this._hash.update(typeof data === 'string' ? Buffer.from(data, enc) : data);\n\n  return this;\n};\n\nSign.prototype.sign = function signMethod(key, enc) {\n  this.end();\n  var hash = this._hash.digest();\n  var sig = sign(hash, key, this._hashType, this._signType, this._tag);\n\n  return enc ? sig.toString(enc) : sig;\n};\n\nfunction Verify(algorithm) {\n  stream.Writable.call(this);\n\n  var data = algorithms[algorithm];\n  if (!data) { throw new Error('Unknown message digest'); }\n\n  this._hash = createHash(data.hash);\n  this._tag = data.id;\n  this._signType = data.sign;\n}\ninherits(Verify, stream.Writable);\n\nVerify.prototype._write = function _write(data, _, done) {\n  this._hash.update(data);\n  done();\n};\n\nVerify.prototype.update = function update(data, enc) {\n  this._hash.update(typeof data === 'string' ? Buffer.from(data, enc) : data);\n\n  return this;\n};\n\nVerify.prototype.verify = function verifyMethod(key, sig, enc) {\n  var sigBuffer = typeof sig === 'string' ? Buffer.from(sig, enc) : sig;\n\n  this.end();\n  var hash = this._hash.digest();\n  return verify(sigBuffer, hash, key, this._signType, this._tag);\n};\n\nfunction createSign(algorithm) {\n  return new Sign(algorithm);\n}\n\nfunction createVerify(algorithm) {\n  return new Verify(algorithm);\n}\n\nmodule.exports = {\n  Sign: createSign,\n  Verify: createVerify,\n  createSign: createSign,\n  createVerify: createVerify\n};\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nvar _Object$setPrototypeO;\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar finished = require('./end-of-stream');\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n  if (resolve !== null) {\n    var data = iter[kStream].read();\n    // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n  next: function next() {\n    var _this = this;\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    }\n\n    // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n    var lastPromise = this[kLastPromise];\n    var promise;\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n      promise = new Promise(this[kHandlePromise]);\n    }\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject];\n      // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n      iterator[kError] = err;\n      return;\n    }\n    var resolve = iterator[kLastResolve];\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\nmodule.exports = createReadableStreamAsyncIterator;","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\nvar Transform = require('./_stream_transform');\nrequire('inherits')(PassThrough, Transform);\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n  ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nrequire('inherits')(Writable, Stream);\nfunction nop() {}\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'finish' (and potentially 'end')\n  this.autoDestroy = !!options.autoDestroy;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex);\n\n  // legacy.\n  this.writable = true;\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END();\n  // TODO: defer error events consistently everywhere, not just the cb\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n  return true;\n}\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n  return ret;\n}\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\nWritable.prototype._writev = null;\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n  return need;\n}\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n\n  // reuse the free corkReq.\n  state.corkedRequestsFree.next = corkReq;\n}\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\nrequire('inherits')(Duplex, Readable);\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(onEndNT, this);\n}\nfunction onEndNT(self) {\n  self.end();\n}\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","module.exports = require('events').EventEmitter;\n","'use strict';\n\nmodule.exports = require('./browser/algorithms.json');\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar _require = require('buffer'),\n  Buffer = _require.Buffer;\nvar _require2 = require('util'),\n  inspect = _require2.inspect;\nvar custom = inspect && inspect.custom || 'inspect';\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\nmodule.exports = /*#__PURE__*/function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n      while (p = p.next) ret += s + p.data;\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes or characters from the buffered data.\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    }\n\n    // Consumes a specified amount of characters from the buffered data.\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes from the buffered data.\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Make sure the linked list only shows the minimal necessary information.\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n  return BufferList;\n}();","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/buffer_list');\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\n// Lazy loaded to improve the startup performance.\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\nrequire('inherits')(Readable, Stream);\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'end' (and potentially 'finish')\n  this.autoDestroy = !!options.autoDestroy;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex);\n\n  // legacy\n  this.readable = true;\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n  Stream.call(this);\n}\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  }\n\n  // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n  return er;\n}\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder;\n  // If setEncoding(null), decoder.encoding equals utf8\n  this._readableState.encoding = this._readableState.decoder.encoding;\n\n  // Iterate over current buffer to convert already stored Buffers:\n  var p = this._readableState.buffer.head;\n  var content = '';\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n  this._readableState.buffer.clear();\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n};\n\n// Don't raise the hwm > 1GB\nvar MAX_HWM = 0x40000000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  }\n\n  // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n  return dest;\n};\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {\n      hasUnpiped: false\n    });\n    return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0;\n\n    // Try start flowing on next tick if stream isn't explicitly paused\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true;\n\n    // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n  state.paused = false;\n  return this;\n};\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n  if (!state.reading) {\n    stream.read(0);\n  }\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  this._readableState.paused = true;\n  return this;\n};\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null);\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n  return this;\n};\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n    return createReadableStreamAsyncIterator(this);\n  };\n}\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n});\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length);\n\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n    return from(Readable, iterable, opts);\n  };\n}\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    callback.apply(this, args);\n  };\n}\nfunction noop() {}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n  var writableEnded = stream._writableState && stream._writableState.finished;\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n  var onclose = function onclose() {\n    var err;\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\nmodule.exports = eos;","'use strict';\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n  return this;\n}\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\nvar _require$codes = require('../errors').codes,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\nvar Duplex = require('./_stream_duplex');\nrequire('inherits')(Transform, Duplex);\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\nfunction prefinish() {\n  var _this = this;\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n","(function (module, exports) {\n  'use strict';\n\n  // Utils\n  function assert (val, msg) {\n    if (!val) throw new Error(msg || 'Assertion failed');\n  }\n\n  // Could use `inherits` module, but don't want to move from single file\n  // architecture yet.\n  function inherits (ctor, superCtor) {\n    ctor.super_ = superCtor;\n    var TempCtor = function () {};\n    TempCtor.prototype = superCtor.prototype;\n    ctor.prototype = new TempCtor();\n    ctor.prototype.constructor = ctor;\n  }\n\n  // BN\n\n  function BN (number, base, endian) {\n    if (BN.isBN(number)) {\n      return number;\n    }\n\n    this.negative = 0;\n    this.words = null;\n    this.length = 0;\n\n    // Reduction context\n    this.red = null;\n\n    if (number !== null) {\n      if (base === 'le' || base === 'be') {\n        endian = base;\n        base = 10;\n      }\n\n      this._init(number || 0, base || 10, endian || 'be');\n    }\n  }\n  if (typeof module === 'object') {\n    module.exports = BN;\n  } else {\n    exports.BN = BN;\n  }\n\n  BN.BN = BN;\n  BN.wordSize = 26;\n\n  var Buffer;\n  try {\n    if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n      Buffer = window.Buffer;\n    } else {\n      Buffer = require('buffer').Buffer;\n    }\n  } catch (e) {\n  }\n\n  BN.isBN = function isBN (num) {\n    if (num instanceof BN) {\n      return true;\n    }\n\n    return num !== null && typeof num === 'object' &&\n      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n  };\n\n  BN.max = function max (left, right) {\n    if (left.cmp(right) > 0) return left;\n    return right;\n  };\n\n  BN.min = function min (left, right) {\n    if (left.cmp(right) < 0) return left;\n    return right;\n  };\n\n  BN.prototype._init = function init (number, base, endian) {\n    if (typeof number === 'number') {\n      return this._initNumber(number, base, endian);\n    }\n\n    if (typeof number === 'object') {\n      return this._initArray(number, base, endian);\n    }\n\n    if (base === 'hex') {\n      base = 16;\n    }\n    assert(base === (base | 0) && base >= 2 && base <= 36);\n\n    number = number.toString().replace(/\\s+/g, '');\n    var start = 0;\n    if (number[0] === '-') {\n      start++;\n      this.negative = 1;\n    }\n\n    if (start < number.length) {\n      if (base === 16) {\n        this._parseHex(number, start, endian);\n      } else {\n        this._parseBase(number, base, start);\n        if (endian === 'le') {\n          this._initArray(this.toArray(), base, endian);\n        }\n      }\n    }\n  };\n\n  BN.prototype._initNumber = function _initNumber (number, base, endian) {\n    if (number < 0) {\n      this.negative = 1;\n      number = -number;\n    }\n    if (number < 0x4000000) {\n      this.words = [number & 0x3ffffff];\n      this.length = 1;\n    } else if (number < 0x10000000000000) {\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff\n      ];\n      this.length = 2;\n    } else {\n      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n      this.words = [\n        number & 0x3ffffff,\n        (number / 0x4000000) & 0x3ffffff,\n        1\n      ];\n      this.length = 3;\n    }\n\n    if (endian !== 'le') return;\n\n    // Reverse the bytes\n    this._initArray(this.toArray(), base, endian);\n  };\n\n  BN.prototype._initArray = function _initArray (number, base, endian) {\n    // Perhaps a Uint8Array\n    assert(typeof number.length === 'number');\n    if (number.length <= 0) {\n      this.words = [0];\n      this.length = 1;\n      return this;\n    }\n\n    this.length = Math.ceil(number.length / 3);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    var j, w;\n    var off = 0;\n    if (endian === 'be') {\n      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    } else if (endian === 'le') {\n      for (i = 0, j = 0; i < number.length; i += 3) {\n        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n        this.words[j] |= (w << off) & 0x3ffffff;\n        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n        off += 24;\n        if (off >= 26) {\n          off -= 26;\n          j++;\n        }\n      }\n    }\n    return this._strip();\n  };\n\n  function parseHex4Bits (string, index) {\n    var c = string.charCodeAt(index);\n    // '0' - '9'\n    if (c >= 48 && c <= 57) {\n      return c - 48;\n    // 'A' - 'F'\n    } else if (c >= 65 && c <= 70) {\n      return c - 55;\n    // 'a' - 'f'\n    } else if (c >= 97 && c <= 102) {\n      return c - 87;\n    } else {\n      assert(false, 'Invalid character in ' + string);\n    }\n  }\n\n  function parseHexByte (string, lowerBound, index) {\n    var r = parseHex4Bits(string, index);\n    if (index - 1 >= lowerBound) {\n      r |= parseHex4Bits(string, index - 1) << 4;\n    }\n    return r;\n  }\n\n  BN.prototype._parseHex = function _parseHex (number, start, endian) {\n    // Create possibly bigger array to ensure that it fits the number\n    this.length = Math.ceil((number.length - start) / 6);\n    this.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      this.words[i] = 0;\n    }\n\n    // 24-bits chunks\n    var off = 0;\n    var j = 0;\n\n    var w;\n    if (endian === 'be') {\n      for (i = number.length - 1; i >= start; i -= 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    } else {\n      var parseLength = number.length - start;\n      for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n        w = parseHexByte(number, start, i) << off;\n        this.words[j] |= w & 0x3ffffff;\n        if (off >= 18) {\n          off -= 18;\n          j += 1;\n          this.words[j] |= w >>> 26;\n        } else {\n          off += 8;\n        }\n      }\n    }\n\n    this._strip();\n  };\n\n  function parseBase (str, start, end, mul) {\n    var r = 0;\n    var b = 0;\n    var len = Math.min(str.length, end);\n    for (var i = start; i < len; i++) {\n      var c = str.charCodeAt(i) - 48;\n\n      r *= mul;\n\n      // 'a'\n      if (c >= 49) {\n        b = c - 49 + 0xa;\n\n      // 'A'\n      } else if (c >= 17) {\n        b = c - 17 + 0xa;\n\n      // '0' - '9'\n      } else {\n        b = c;\n      }\n      assert(c >= 0 && b < mul, 'Invalid character');\n      r += b;\n    }\n    return r;\n  }\n\n  BN.prototype._parseBase = function _parseBase (number, base, start) {\n    // Initialize as zero\n    this.words = [0];\n    this.length = 1;\n\n    // Find length of limb in base\n    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n      limbLen++;\n    }\n    limbLen--;\n    limbPow = (limbPow / base) | 0;\n\n    var total = number.length - start;\n    var mod = total % limbLen;\n    var end = Math.min(total, total - mod) + start;\n\n    var word = 0;\n    for (var i = start; i < end; i += limbLen) {\n      word = parseBase(number, i, i + limbLen, base);\n\n      this.imuln(limbPow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    if (mod !== 0) {\n      var pow = 1;\n      word = parseBase(number, i, number.length, base);\n\n      for (i = 0; i < mod; i++) {\n        pow *= base;\n      }\n\n      this.imuln(pow);\n      if (this.words[0] + word < 0x4000000) {\n        this.words[0] += word;\n      } else {\n        this._iaddn(word);\n      }\n    }\n\n    this._strip();\n  };\n\n  BN.prototype.copy = function copy (dest) {\n    dest.words = new Array(this.length);\n    for (var i = 0; i < this.length; i++) {\n      dest.words[i] = this.words[i];\n    }\n    dest.length = this.length;\n    dest.negative = this.negative;\n    dest.red = this.red;\n  };\n\n  function move (dest, src) {\n    dest.words = src.words;\n    dest.length = src.length;\n    dest.negative = src.negative;\n    dest.red = src.red;\n  }\n\n  BN.prototype._move = function _move (dest) {\n    move(dest, this);\n  };\n\n  BN.prototype.clone = function clone () {\n    var r = new BN(null);\n    this.copy(r);\n    return r;\n  };\n\n  BN.prototype._expand = function _expand (size) {\n    while (this.length < size) {\n      this.words[this.length++] = 0;\n    }\n    return this;\n  };\n\n  // Remove leading `0` from `this`\n  BN.prototype._strip = function strip () {\n    while (this.length > 1 && this.words[this.length - 1] === 0) {\n      this.length--;\n    }\n    return this._normSign();\n  };\n\n  BN.prototype._normSign = function _normSign () {\n    // -0 = 0\n    if (this.length === 1 && this.words[0] === 0) {\n      this.negative = 0;\n    }\n    return this;\n  };\n\n  // Check Symbol.for because not everywhere where Symbol defined\n  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility\n  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {\n    try {\n      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;\n    } catch (e) {\n      BN.prototype.inspect = inspect;\n    }\n  } else {\n    BN.prototype.inspect = inspect;\n  }\n\n  function inspect () {\n    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n  }\n\n  /*\n\n  var zeros = [];\n  var groupSizes = [];\n  var groupBases = [];\n\n  var s = '';\n  var i = -1;\n  while (++i < BN.wordSize) {\n    zeros[i] = s;\n    s += '0';\n  }\n  groupSizes[0] = 0;\n  groupSizes[1] = 0;\n  groupBases[0] = 0;\n  groupBases[1] = 0;\n  var base = 2 - 1;\n  while (++base < 36 + 1) {\n    var groupSize = 0;\n    var groupBase = 1;\n    while (groupBase < (1 << BN.wordSize) / base) {\n      groupBase *= base;\n      groupSize += 1;\n    }\n    groupSizes[base] = groupSize;\n    groupBases[base] = groupBase;\n  }\n\n  */\n\n  var zeros = [\n    '',\n    '0',\n    '00',\n    '000',\n    '0000',\n    '00000',\n    '000000',\n    '0000000',\n    '00000000',\n    '000000000',\n    '0000000000',\n    '00000000000',\n    '000000000000',\n    '0000000000000',\n    '00000000000000',\n    '000000000000000',\n    '0000000000000000',\n    '00000000000000000',\n    '000000000000000000',\n    '0000000000000000000',\n    '00000000000000000000',\n    '000000000000000000000',\n    '0000000000000000000000',\n    '00000000000000000000000',\n    '000000000000000000000000',\n    '0000000000000000000000000'\n  ];\n\n  var groupSizes = [\n    0, 0,\n    25, 16, 12, 11, 10, 9, 8,\n    8, 7, 7, 7, 7, 6, 6,\n    6, 6, 6, 6, 6, 5, 5,\n    5, 5, 5, 5, 5, 5, 5,\n    5, 5, 5, 5, 5, 5, 5\n  ];\n\n  var groupBases = [\n    0, 0,\n    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n  ];\n\n  BN.prototype.toString = function toString (base, padding) {\n    base = base || 10;\n    padding = padding | 0 || 1;\n\n    var out;\n    if (base === 16 || base === 'hex') {\n      out = '';\n      var off = 0;\n      var carry = 0;\n      for (var i = 0; i < this.length; i++) {\n        var w = this.words[i];\n        var word = (((w << off) | carry) & 0xffffff).toString(16);\n        carry = (w >>> (24 - off)) & 0xffffff;\n        off += 2;\n        if (off >= 26) {\n          off -= 26;\n          i--;\n        }\n        if (carry !== 0 || i !== this.length - 1) {\n          out = zeros[6 - word.length] + word + out;\n        } else {\n          out = word + out;\n        }\n      }\n      if (carry !== 0) {\n        out = carry.toString(16) + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    if (base === (base | 0) && base >= 2 && base <= 36) {\n      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n      var groupSize = groupSizes[base];\n      // var groupBase = Math.pow(base, groupSize);\n      var groupBase = groupBases[base];\n      out = '';\n      var c = this.clone();\n      c.negative = 0;\n      while (!c.isZero()) {\n        var r = c.modrn(groupBase).toString(base);\n        c = c.idivn(groupBase);\n\n        if (!c.isZero()) {\n          out = zeros[groupSize - r.length] + r + out;\n        } else {\n          out = r + out;\n        }\n      }\n      if (this.isZero()) {\n        out = '0' + out;\n      }\n      while (out.length % padding !== 0) {\n        out = '0' + out;\n      }\n      if (this.negative !== 0) {\n        out = '-' + out;\n      }\n      return out;\n    }\n\n    assert(false, 'Base should be between 2 and 36');\n  };\n\n  BN.prototype.toNumber = function toNumber () {\n    var ret = this.words[0];\n    if (this.length === 2) {\n      ret += this.words[1] * 0x4000000;\n    } else if (this.length === 3 && this.words[2] === 0x01) {\n      // NOTE: at this stage it is known that the top bit is set\n      ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n    } else if (this.length > 2) {\n      assert(false, 'Number can only safely store up to 53 bits');\n    }\n    return (this.negative !== 0) ? -ret : ret;\n  };\n\n  BN.prototype.toJSON = function toJSON () {\n    return this.toString(16, 2);\n  };\n\n  if (Buffer) {\n    BN.prototype.toBuffer = function toBuffer (endian, length) {\n      return this.toArrayLike(Buffer, endian, length);\n    };\n  }\n\n  BN.prototype.toArray = function toArray (endian, length) {\n    return this.toArrayLike(Array, endian, length);\n  };\n\n  var allocate = function allocate (ArrayType, size) {\n    if (ArrayType.allocUnsafe) {\n      return ArrayType.allocUnsafe(size);\n    }\n    return new ArrayType(size);\n  };\n\n  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n    this._strip();\n\n    var byteLength = this.byteLength();\n    var reqLength = length || Math.max(1, byteLength);\n    assert(byteLength <= reqLength, 'byte array longer than desired length');\n    assert(reqLength > 0, 'Requested array length <= 0');\n\n    var res = allocate(ArrayType, reqLength);\n    var postfix = endian === 'le' ? 'LE' : 'BE';\n    this['_toArrayLike' + postfix](res, byteLength);\n    return res;\n  };\n\n  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {\n    var position = 0;\n    var carry = 0;\n\n    for (var i = 0, shift = 0; i < this.length; i++) {\n      var word = (this.words[i] << shift) | carry;\n\n      res[position++] = word & 0xff;\n      if (position < res.length) {\n        res[position++] = (word >> 8) & 0xff;\n      }\n      if (position < res.length) {\n        res[position++] = (word >> 16) & 0xff;\n      }\n\n      if (shift === 6) {\n        if (position < res.length) {\n          res[position++] = (word >> 24) & 0xff;\n        }\n        carry = 0;\n        shift = 0;\n      } else {\n        carry = word >>> 24;\n        shift += 2;\n      }\n    }\n\n    if (position < res.length) {\n      res[position++] = carry;\n\n      while (position < res.length) {\n        res[position++] = 0;\n      }\n    }\n  };\n\n  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {\n    var position = res.length - 1;\n    var carry = 0;\n\n    for (var i = 0, shift = 0; i < this.length; i++) {\n      var word = (this.words[i] << shift) | carry;\n\n      res[position--] = word & 0xff;\n      if (position >= 0) {\n        res[position--] = (word >> 8) & 0xff;\n      }\n      if (position >= 0) {\n        res[position--] = (word >> 16) & 0xff;\n      }\n\n      if (shift === 6) {\n        if (position >= 0) {\n          res[position--] = (word >> 24) & 0xff;\n        }\n        carry = 0;\n        shift = 0;\n      } else {\n        carry = word >>> 24;\n        shift += 2;\n      }\n    }\n\n    if (position >= 0) {\n      res[position--] = carry;\n\n      while (position >= 0) {\n        res[position--] = 0;\n      }\n    }\n  };\n\n  if (Math.clz32) {\n    BN.prototype._countBits = function _countBits (w) {\n      return 32 - Math.clz32(w);\n    };\n  } else {\n    BN.prototype._countBits = function _countBits (w) {\n      var t = w;\n      var r = 0;\n      if (t >= 0x1000) {\n        r += 13;\n        t >>>= 13;\n      }\n      if (t >= 0x40) {\n        r += 7;\n        t >>>= 7;\n      }\n      if (t >= 0x8) {\n        r += 4;\n        t >>>= 4;\n      }\n      if (t >= 0x02) {\n        r += 2;\n        t >>>= 2;\n      }\n      return r + t;\n    };\n  }\n\n  BN.prototype._zeroBits = function _zeroBits (w) {\n    // Short-cut\n    if (w === 0) return 26;\n\n    var t = w;\n    var r = 0;\n    if ((t & 0x1fff) === 0) {\n      r += 13;\n      t >>>= 13;\n    }\n    if ((t & 0x7f) === 0) {\n      r += 7;\n      t >>>= 7;\n    }\n    if ((t & 0xf) === 0) {\n      r += 4;\n      t >>>= 4;\n    }\n    if ((t & 0x3) === 0) {\n      r += 2;\n      t >>>= 2;\n    }\n    if ((t & 0x1) === 0) {\n      r++;\n    }\n    return r;\n  };\n\n  // Return number of used bits in a BN\n  BN.prototype.bitLength = function bitLength () {\n    var w = this.words[this.length - 1];\n    var hi = this._countBits(w);\n    return (this.length - 1) * 26 + hi;\n  };\n\n  function toBitArray (num) {\n    var w = new Array(num.bitLength());\n\n    for (var bit = 0; bit < w.length; bit++) {\n      var off = (bit / 26) | 0;\n      var wbit = bit % 26;\n\n      w[bit] = (num.words[off] >>> wbit) & 0x01;\n    }\n\n    return w;\n  }\n\n  // Number of trailing zero bits\n  BN.prototype.zeroBits = function zeroBits () {\n    if (this.isZero()) return 0;\n\n    var r = 0;\n    for (var i = 0; i < this.length; i++) {\n      var b = this._zeroBits(this.words[i]);\n      r += b;\n      if (b !== 26) break;\n    }\n    return r;\n  };\n\n  BN.prototype.byteLength = function byteLength () {\n    return Math.ceil(this.bitLength() / 8);\n  };\n\n  BN.prototype.toTwos = function toTwos (width) {\n    if (this.negative !== 0) {\n      return this.abs().inotn(width).iaddn(1);\n    }\n    return this.clone();\n  };\n\n  BN.prototype.fromTwos = function fromTwos (width) {\n    if (this.testn(width - 1)) {\n      return this.notn(width).iaddn(1).ineg();\n    }\n    return this.clone();\n  };\n\n  BN.prototype.isNeg = function isNeg () {\n    return this.negative !== 0;\n  };\n\n  // Return negative clone of `this`\n  BN.prototype.neg = function neg () {\n    return this.clone().ineg();\n  };\n\n  BN.prototype.ineg = function ineg () {\n    if (!this.isZero()) {\n      this.negative ^= 1;\n    }\n\n    return this;\n  };\n\n  // Or `num` with `this` in-place\n  BN.prototype.iuor = function iuor (num) {\n    while (this.length < num.length) {\n      this.words[this.length++] = 0;\n    }\n\n    for (var i = 0; i < num.length; i++) {\n      this.words[i] = this.words[i] | num.words[i];\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ior = function ior (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuor(num);\n  };\n\n  // Or `num` with `this`\n  BN.prototype.or = function or (num) {\n    if (this.length > num.length) return this.clone().ior(num);\n    return num.clone().ior(this);\n  };\n\n  BN.prototype.uor = function uor (num) {\n    if (this.length > num.length) return this.clone().iuor(num);\n    return num.clone().iuor(this);\n  };\n\n  // And `num` with `this` in-place\n  BN.prototype.iuand = function iuand (num) {\n    // b = min-length(num, this)\n    var b;\n    if (this.length > num.length) {\n      b = num;\n    } else {\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = this.words[i] & num.words[i];\n    }\n\n    this.length = b.length;\n\n    return this._strip();\n  };\n\n  BN.prototype.iand = function iand (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuand(num);\n  };\n\n  // And `num` with `this`\n  BN.prototype.and = function and (num) {\n    if (this.length > num.length) return this.clone().iand(num);\n    return num.clone().iand(this);\n  };\n\n  BN.prototype.uand = function uand (num) {\n    if (this.length > num.length) return this.clone().iuand(num);\n    return num.clone().iuand(this);\n  };\n\n  // Xor `num` with `this` in-place\n  BN.prototype.iuxor = function iuxor (num) {\n    // a.length > b.length\n    var a;\n    var b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    for (var i = 0; i < b.length; i++) {\n      this.words[i] = a.words[i] ^ b.words[i];\n    }\n\n    if (this !== a) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = a.length;\n\n    return this._strip();\n  };\n\n  BN.prototype.ixor = function ixor (num) {\n    assert((this.negative | num.negative) === 0);\n    return this.iuxor(num);\n  };\n\n  // Xor `num` with `this`\n  BN.prototype.xor = function xor (num) {\n    if (this.length > num.length) return this.clone().ixor(num);\n    return num.clone().ixor(this);\n  };\n\n  BN.prototype.uxor = function uxor (num) {\n    if (this.length > num.length) return this.clone().iuxor(num);\n    return num.clone().iuxor(this);\n  };\n\n  // Not ``this`` with ``width`` bitwidth\n  BN.prototype.inotn = function inotn (width) {\n    assert(typeof width === 'number' && width >= 0);\n\n    var bytesNeeded = Math.ceil(width / 26) | 0;\n    var bitsLeft = width % 26;\n\n    // Extend the buffer with leading zeroes\n    this._expand(bytesNeeded);\n\n    if (bitsLeft > 0) {\n      bytesNeeded--;\n    }\n\n    // Handle complete words\n    for (var i = 0; i < bytesNeeded; i++) {\n      this.words[i] = ~this.words[i] & 0x3ffffff;\n    }\n\n    // Handle the residue\n    if (bitsLeft > 0) {\n      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n    }\n\n    // And remove leading zeroes\n    return this._strip();\n  };\n\n  BN.prototype.notn = function notn (width) {\n    return this.clone().inotn(width);\n  };\n\n  // Set `bit` of `this`\n  BN.prototype.setn = function setn (bit, val) {\n    assert(typeof bit === 'number' && bit >= 0);\n\n    var off = (bit / 26) | 0;\n    var wbit = bit % 26;\n\n    this._expand(off + 1);\n\n    if (val) {\n      this.words[off] = this.words[off] | (1 << wbit);\n    } else {\n      this.words[off] = this.words[off] & ~(1 << wbit);\n    }\n\n    return this._strip();\n  };\n\n  // Add `num` to `this` in-place\n  BN.prototype.iadd = function iadd (num) {\n    var r;\n\n    // negative + positive\n    if (this.negative !== 0 && num.negative === 0) {\n      this.negative = 0;\n      r = this.isub(num);\n      this.negative ^= 1;\n      return this._normSign();\n\n    // positive + negative\n    } else if (this.negative === 0 && num.negative !== 0) {\n      num.negative = 0;\n      r = this.isub(num);\n      num.negative = 1;\n      return r._normSign();\n    }\n\n    // a.length > b.length\n    var a, b;\n    if (this.length > num.length) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      this.words[i] = r & 0x3ffffff;\n      carry = r >>> 26;\n    }\n\n    this.length = a.length;\n    if (carry !== 0) {\n      this.words[this.length] = carry;\n      this.length++;\n    // Copy the rest of the words\n    } else if (a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    return this;\n  };\n\n  // Add `num` to `this`\n  BN.prototype.add = function add (num) {\n    var res;\n    if (num.negative !== 0 && this.negative === 0) {\n      num.negative = 0;\n      res = this.sub(num);\n      num.negative ^= 1;\n      return res;\n    } else if (num.negative === 0 && this.negative !== 0) {\n      this.negative = 0;\n      res = num.sub(this);\n      this.negative = 1;\n      return res;\n    }\n\n    if (this.length > num.length) return this.clone().iadd(num);\n\n    return num.clone().iadd(this);\n  };\n\n  // Subtract `num` from `this` in-place\n  BN.prototype.isub = function isub (num) {\n    // this - (-num) = this + num\n    if (num.negative !== 0) {\n      num.negative = 0;\n      var r = this.iadd(num);\n      num.negative = 1;\n      return r._normSign();\n\n    // -this - num = -(this + num)\n    } else if (this.negative !== 0) {\n      this.negative = 0;\n      this.iadd(num);\n      this.negative = 1;\n      return this._normSign();\n    }\n\n    // At this point both numbers are positive\n    var cmp = this.cmp(num);\n\n    // Optimization - zeroify\n    if (cmp === 0) {\n      this.negative = 0;\n      this.length = 1;\n      this.words[0] = 0;\n      return this;\n    }\n\n    // a > b\n    var a, b;\n    if (cmp > 0) {\n      a = this;\n      b = num;\n    } else {\n      a = num;\n      b = this;\n    }\n\n    var carry = 0;\n    for (var i = 0; i < b.length; i++) {\n      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n    for (; carry !== 0 && i < a.length; i++) {\n      r = (a.words[i] | 0) + carry;\n      carry = r >> 26;\n      this.words[i] = r & 0x3ffffff;\n    }\n\n    // Copy rest of the words\n    if (carry === 0 && i < a.length && a !== this) {\n      for (; i < a.length; i++) {\n        this.words[i] = a.words[i];\n      }\n    }\n\n    this.length = Math.max(this.length, i);\n\n    if (a !== this) {\n      this.negative = 1;\n    }\n\n    return this._strip();\n  };\n\n  // Subtract `num` from `this`\n  BN.prototype.sub = function sub (num) {\n    return this.clone().isub(num);\n  };\n\n  function smallMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    var len = (self.length + num.length) | 0;\n    out.length = len;\n    len = (len - 1) | 0;\n\n    // Peel one iteration (compiler can't do it, because of code complexity)\n    var a = self.words[0] | 0;\n    var b = num.words[0] | 0;\n    var r = a * b;\n\n    var lo = r & 0x3ffffff;\n    var carry = (r / 0x4000000) | 0;\n    out.words[0] = lo;\n\n    for (var k = 1; k < len; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = carry >>> 26;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = (k - j) | 0;\n        a = self.words[i] | 0;\n        b = num.words[j] | 0;\n        r = a * b + rword;\n        ncarry += (r / 0x4000000) | 0;\n        rword = r & 0x3ffffff;\n      }\n      out.words[k] = rword | 0;\n      carry = ncarry | 0;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry | 0;\n    } else {\n      out.length--;\n    }\n\n    return out._strip();\n  }\n\n  // TODO(indutny): it may be reasonable to omit it for users who don't need\n  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n  // multiplication (like elliptic secp256k1).\n  var comb10MulTo = function comb10MulTo (self, num, out) {\n    var a = self.words;\n    var b = num.words;\n    var o = out.words;\n    var c = 0;\n    var lo;\n    var mid;\n    var hi;\n    var a0 = a[0] | 0;\n    var al0 = a0 & 0x1fff;\n    var ah0 = a0 >>> 13;\n    var a1 = a[1] | 0;\n    var al1 = a1 & 0x1fff;\n    var ah1 = a1 >>> 13;\n    var a2 = a[2] | 0;\n    var al2 = a2 & 0x1fff;\n    var ah2 = a2 >>> 13;\n    var a3 = a[3] | 0;\n    var al3 = a3 & 0x1fff;\n    var ah3 = a3 >>> 13;\n    var a4 = a[4] | 0;\n    var al4 = a4 & 0x1fff;\n    var ah4 = a4 >>> 13;\n    var a5 = a[5] | 0;\n    var al5 = a5 & 0x1fff;\n    var ah5 = a5 >>> 13;\n    var a6 = a[6] | 0;\n    var al6 = a6 & 0x1fff;\n    var ah6 = a6 >>> 13;\n    var a7 = a[7] | 0;\n    var al7 = a7 & 0x1fff;\n    var ah7 = a7 >>> 13;\n    var a8 = a[8] | 0;\n    var al8 = a8 & 0x1fff;\n    var ah8 = a8 >>> 13;\n    var a9 = a[9] | 0;\n    var al9 = a9 & 0x1fff;\n    var ah9 = a9 >>> 13;\n    var b0 = b[0] | 0;\n    var bl0 = b0 & 0x1fff;\n    var bh0 = b0 >>> 13;\n    var b1 = b[1] | 0;\n    var bl1 = b1 & 0x1fff;\n    var bh1 = b1 >>> 13;\n    var b2 = b[2] | 0;\n    var bl2 = b2 & 0x1fff;\n    var bh2 = b2 >>> 13;\n    var b3 = b[3] | 0;\n    var bl3 = b3 & 0x1fff;\n    var bh3 = b3 >>> 13;\n    var b4 = b[4] | 0;\n    var bl4 = b4 & 0x1fff;\n    var bh4 = b4 >>> 13;\n    var b5 = b[5] | 0;\n    var bl5 = b5 & 0x1fff;\n    var bh5 = b5 >>> 13;\n    var b6 = b[6] | 0;\n    var bl6 = b6 & 0x1fff;\n    var bh6 = b6 >>> 13;\n    var b7 = b[7] | 0;\n    var bl7 = b7 & 0x1fff;\n    var bh7 = b7 >>> 13;\n    var b8 = b[8] | 0;\n    var bl8 = b8 & 0x1fff;\n    var bh8 = b8 >>> 13;\n    var b9 = b[9] | 0;\n    var bl9 = b9 & 0x1fff;\n    var bh9 = b9 >>> 13;\n\n    out.negative = self.negative ^ num.negative;\n    out.length = 19;\n    /* k = 0 */\n    lo = Math.imul(al0, bl0);\n    mid = Math.imul(al0, bh0);\n    mid = (mid + Math.imul(ah0, bl0)) | 0;\n    hi = Math.imul(ah0, bh0);\n    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n    w0 &= 0x3ffffff;\n    /* k = 1 */\n    lo = Math.imul(al1, bl0);\n    mid = Math.imul(al1, bh0);\n    mid = (mid + Math.imul(ah1, bl0)) | 0;\n    hi = Math.imul(ah1, bh0);\n    lo = (lo + Math.imul(al0, bl1)) | 0;\n    mid = (mid + Math.imul(al0, bh1)) | 0;\n    mid = (mid + Math.imul(ah0, bl1)) | 0;\n    hi = (hi + Math.imul(ah0, bh1)) | 0;\n    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n    w1 &= 0x3ffffff;\n    /* k = 2 */\n    lo = Math.imul(al2, bl0);\n    mid = Math.imul(al2, bh0);\n    mid = (mid + Math.imul(ah2, bl0)) | 0;\n    hi = Math.imul(ah2, bh0);\n    lo = (lo + Math.imul(al1, bl1)) | 0;\n    mid = (mid + Math.imul(al1, bh1)) | 0;\n    mid = (mid + Math.imul(ah1, bl1)) | 0;\n    hi = (hi + Math.imul(ah1, bh1)) | 0;\n    lo = (lo + Math.imul(al0, bl2)) | 0;\n    mid = (mid + Math.imul(al0, bh2)) | 0;\n    mid = (mid + Math.imul(ah0, bl2)) | 0;\n    hi = (hi + Math.imul(ah0, bh2)) | 0;\n    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n    w2 &= 0x3ffffff;\n    /* k = 3 */\n    lo = Math.imul(al3, bl0);\n    mid = Math.imul(al3, bh0);\n    mid = (mid + Math.imul(ah3, bl0)) | 0;\n    hi = Math.imul(ah3, bh0);\n    lo = (lo + Math.imul(al2, bl1)) | 0;\n    mid = (mid + Math.imul(al2, bh1)) | 0;\n    mid = (mid + Math.imul(ah2, bl1)) | 0;\n    hi = (hi + Math.imul(ah2, bh1)) | 0;\n    lo = (lo + Math.imul(al1, bl2)) | 0;\n    mid = (mid + Math.imul(al1, bh2)) | 0;\n    mid = (mid + Math.imul(ah1, bl2)) | 0;\n    hi = (hi + Math.imul(ah1, bh2)) | 0;\n    lo = (lo + Math.imul(al0, bl3)) | 0;\n    mid = (mid + Math.imul(al0, bh3)) | 0;\n    mid = (mid + Math.imul(ah0, bl3)) | 0;\n    hi = (hi + Math.imul(ah0, bh3)) | 0;\n    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n    w3 &= 0x3ffffff;\n    /* k = 4 */\n    lo = Math.imul(al4, bl0);\n    mid = Math.imul(al4, bh0);\n    mid = (mid + Math.imul(ah4, bl0)) | 0;\n    hi = Math.imul(ah4, bh0);\n    lo = (lo + Math.imul(al3, bl1)) | 0;\n    mid = (mid + Math.imul(al3, bh1)) | 0;\n    mid = (mid + Math.imul(ah3, bl1)) | 0;\n    hi = (hi + Math.imul(ah3, bh1)) | 0;\n    lo = (lo + Math.imul(al2, bl2)) | 0;\n    mid = (mid + Math.imul(al2, bh2)) | 0;\n    mid = (mid + Math.imul(ah2, bl2)) | 0;\n    hi = (hi + Math.imul(ah2, bh2)) | 0;\n    lo = (lo + Math.imul(al1, bl3)) | 0;\n    mid = (mid + Math.imul(al1, bh3)) | 0;\n    mid = (mid + Math.imul(ah1, bl3)) | 0;\n    hi = (hi + Math.imul(ah1, bh3)) | 0;\n    lo = (lo + Math.imul(al0, bl4)) | 0;\n    mid = (mid + Math.imul(al0, bh4)) | 0;\n    mid = (mid + Math.imul(ah0, bl4)) | 0;\n    hi = (hi + Math.imul(ah0, bh4)) | 0;\n    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n    w4 &= 0x3ffffff;\n    /* k = 5 */\n    lo = Math.imul(al5, bl0);\n    mid = Math.imul(al5, bh0);\n    mid = (mid + Math.imul(ah5, bl0)) | 0;\n    hi = Math.imul(ah5, bh0);\n    lo = (lo + Math.imul(al4, bl1)) | 0;\n    mid = (mid + Math.imul(al4, bh1)) | 0;\n    mid = (mid + Math.imul(ah4, bl1)) | 0;\n    hi = (hi + Math.imul(ah4, bh1)) | 0;\n    lo = (lo + Math.imul(al3, bl2)) | 0;\n    mid = (mid + Math.imul(al3, bh2)) | 0;\n    mid = (mid + Math.imul(ah3, bl2)) | 0;\n    hi = (hi + Math.imul(ah3, bh2)) | 0;\n    lo = (lo + Math.imul(al2, bl3)) | 0;\n    mid = (mid + Math.imul(al2, bh3)) | 0;\n    mid = (mid + Math.imul(ah2, bl3)) | 0;\n    hi = (hi + Math.imul(ah2, bh3)) | 0;\n    lo = (lo + Math.imul(al1, bl4)) | 0;\n    mid = (mid + Math.imul(al1, bh4)) | 0;\n    mid = (mid + Math.imul(ah1, bl4)) | 0;\n    hi = (hi + Math.imul(ah1, bh4)) | 0;\n    lo = (lo + Math.imul(al0, bl5)) | 0;\n    mid = (mid + Math.imul(al0, bh5)) | 0;\n    mid = (mid + Math.imul(ah0, bl5)) | 0;\n    hi = (hi + Math.imul(ah0, bh5)) | 0;\n    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n    w5 &= 0x3ffffff;\n    /* k = 6 */\n    lo = Math.imul(al6, bl0);\n    mid = Math.imul(al6, bh0);\n    mid = (mid + Math.imul(ah6, bl0)) | 0;\n    hi = Math.imul(ah6, bh0);\n    lo = (lo + Math.imul(al5, bl1)) | 0;\n    mid = (mid + Math.imul(al5, bh1)) | 0;\n    mid = (mid + Math.imul(ah5, bl1)) | 0;\n    hi = (hi + Math.imul(ah5, bh1)) | 0;\n    lo = (lo + Math.imul(al4, bl2)) | 0;\n    mid = (mid + Math.imul(al4, bh2)) | 0;\n    mid = (mid + Math.imul(ah4, bl2)) | 0;\n    hi = (hi + Math.imul(ah4, bh2)) | 0;\n    lo = (lo + Math.imul(al3, bl3)) | 0;\n    mid = (mid + Math.imul(al3, bh3)) | 0;\n    mid = (mid + Math.imul(ah3, bl3)) | 0;\n    hi = (hi + Math.imul(ah3, bh3)) | 0;\n    lo = (lo + Math.imul(al2, bl4)) | 0;\n    mid = (mid + Math.imul(al2, bh4)) | 0;\n    mid = (mid + Math.imul(ah2, bl4)) | 0;\n    hi = (hi + Math.imul(ah2, bh4)) | 0;\n    lo = (lo + Math.imul(al1, bl5)) | 0;\n    mid = (mid + Math.imul(al1, bh5)) | 0;\n    mid = (mid + Math.imul(ah1, bl5)) | 0;\n    hi = (hi + Math.imul(ah1, bh5)) | 0;\n    lo = (lo + Math.imul(al0, bl6)) | 0;\n    mid = (mid + Math.imul(al0, bh6)) | 0;\n    mid = (mid + Math.imul(ah0, bl6)) | 0;\n    hi = (hi + Math.imul(ah0, bh6)) | 0;\n    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n    w6 &= 0x3ffffff;\n    /* k = 7 */\n    lo = Math.imul(al7, bl0);\n    mid = Math.imul(al7, bh0);\n    mid = (mid + Math.imul(ah7, bl0)) | 0;\n    hi = Math.imul(ah7, bh0);\n    lo = (lo + Math.imul(al6, bl1)) | 0;\n    mid = (mid + Math.imul(al6, bh1)) | 0;\n    mid = (mid + Math.imul(ah6, bl1)) | 0;\n    hi = (hi + Math.imul(ah6, bh1)) | 0;\n    lo = (lo + Math.imul(al5, bl2)) | 0;\n    mid = (mid + Math.imul(al5, bh2)) | 0;\n    mid = (mid + Math.imul(ah5, bl2)) | 0;\n    hi = (hi + Math.imul(ah5, bh2)) | 0;\n    lo = (lo + Math.imul(al4, bl3)) | 0;\n    mid = (mid + Math.imul(al4, bh3)) | 0;\n    mid = (mid + Math.imul(ah4, bl3)) | 0;\n    hi = (hi + Math.imul(ah4, bh3)) | 0;\n    lo = (lo + Math.imul(al3, bl4)) | 0;\n    mid = (mid + Math.imul(al3, bh4)) | 0;\n    mid = (mid + Math.imul(ah3, bl4)) | 0;\n    hi = (hi + Math.imul(ah3, bh4)) | 0;\n    lo = (lo + Math.imul(al2, bl5)) | 0;\n    mid = (mid + Math.imul(al2, bh5)) | 0;\n    mid = (mid + Math.imul(ah2, bl5)) | 0;\n    hi = (hi + Math.imul(ah2, bh5)) | 0;\n    lo = (lo + Math.imul(al1, bl6)) | 0;\n    mid = (mid + Math.imul(al1, bh6)) | 0;\n    mid = (mid + Math.imul(ah1, bl6)) | 0;\n    hi = (hi + Math.imul(ah1, bh6)) | 0;\n    lo = (lo + Math.imul(al0, bl7)) | 0;\n    mid = (mid + Math.imul(al0, bh7)) | 0;\n    mid = (mid + Math.imul(ah0, bl7)) | 0;\n    hi = (hi + Math.imul(ah0, bh7)) | 0;\n    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n    w7 &= 0x3ffffff;\n    /* k = 8 */\n    lo = Math.imul(al8, bl0);\n    mid = Math.imul(al8, bh0);\n    mid = (mid + Math.imul(ah8, bl0)) | 0;\n    hi = Math.imul(ah8, bh0);\n    lo = (lo + Math.imul(al7, bl1)) | 0;\n    mid = (mid + Math.imul(al7, bh1)) | 0;\n    mid = (mid + Math.imul(ah7, bl1)) | 0;\n    hi = (hi + Math.imul(ah7, bh1)) | 0;\n    lo = (lo + Math.imul(al6, bl2)) | 0;\n    mid = (mid + Math.imul(al6, bh2)) | 0;\n    mid = (mid + Math.imul(ah6, bl2)) | 0;\n    hi = (hi + Math.imul(ah6, bh2)) | 0;\n    lo = (lo + Math.imul(al5, bl3)) | 0;\n    mid = (mid + Math.imul(al5, bh3)) | 0;\n    mid = (mid + Math.imul(ah5, bl3)) | 0;\n    hi = (hi + Math.imul(ah5, bh3)) | 0;\n    lo = (lo + Math.imul(al4, bl4)) | 0;\n    mid = (mid + Math.imul(al4, bh4)) | 0;\n    mid = (mid + Math.imul(ah4, bl4)) | 0;\n    hi = (hi + Math.imul(ah4, bh4)) | 0;\n    lo = (lo + Math.imul(al3, bl5)) | 0;\n    mid = (mid + Math.imul(al3, bh5)) | 0;\n    mid = (mid + Math.imul(ah3, bl5)) | 0;\n    hi = (hi + Math.imul(ah3, bh5)) | 0;\n    lo = (lo + Math.imul(al2, bl6)) | 0;\n    mid = (mid + Math.imul(al2, bh6)) | 0;\n    mid = (mid + Math.imul(ah2, bl6)) | 0;\n    hi = (hi + Math.imul(ah2, bh6)) | 0;\n    lo = (lo + Math.imul(al1, bl7)) | 0;\n    mid = (mid + Math.imul(al1, bh7)) | 0;\n    mid = (mid + Math.imul(ah1, bl7)) | 0;\n    hi = (hi + Math.imul(ah1, bh7)) | 0;\n    lo = (lo + Math.imul(al0, bl8)) | 0;\n    mid = (mid + Math.imul(al0, bh8)) | 0;\n    mid = (mid + Math.imul(ah0, bl8)) | 0;\n    hi = (hi + Math.imul(ah0, bh8)) | 0;\n    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n    w8 &= 0x3ffffff;\n    /* k = 9 */\n    lo = Math.imul(al9, bl0);\n    mid = Math.imul(al9, bh0);\n    mid = (mid + Math.imul(ah9, bl0)) | 0;\n    hi = Math.imul(ah9, bh0);\n    lo = (lo + Math.imul(al8, bl1)) | 0;\n    mid = (mid + Math.imul(al8, bh1)) | 0;\n    mid = (mid + Math.imul(ah8, bl1)) | 0;\n    hi = (hi + Math.imul(ah8, bh1)) | 0;\n    lo = (lo + Math.imul(al7, bl2)) | 0;\n    mid = (mid + Math.imul(al7, bh2)) | 0;\n    mid = (mid + Math.imul(ah7, bl2)) | 0;\n    hi = (hi + Math.imul(ah7, bh2)) | 0;\n    lo = (lo + Math.imul(al6, bl3)) | 0;\n    mid = (mid + Math.imul(al6, bh3)) | 0;\n    mid = (mid + Math.imul(ah6, bl3)) | 0;\n    hi = (hi + Math.imul(ah6, bh3)) | 0;\n    lo = (lo + Math.imul(al5, bl4)) | 0;\n    mid = (mid + Math.imul(al5, bh4)) | 0;\n    mid = (mid + Math.imul(ah5, bl4)) | 0;\n    hi = (hi + Math.imul(ah5, bh4)) | 0;\n    lo = (lo + Math.imul(al4, bl5)) | 0;\n    mid = (mid + Math.imul(al4, bh5)) | 0;\n    mid = (mid + Math.imul(ah4, bl5)) | 0;\n    hi = (hi + Math.imul(ah4, bh5)) | 0;\n    lo = (lo + Math.imul(al3, bl6)) | 0;\n    mid = (mid + Math.imul(al3, bh6)) | 0;\n    mid = (mid + Math.imul(ah3, bl6)) | 0;\n    hi = (hi + Math.imul(ah3, bh6)) | 0;\n    lo = (lo + Math.imul(al2, bl7)) | 0;\n    mid = (mid + Math.imul(al2, bh7)) | 0;\n    mid = (mid + Math.imul(ah2, bl7)) | 0;\n    hi = (hi + Math.imul(ah2, bh7)) | 0;\n    lo = (lo + Math.imul(al1, bl8)) | 0;\n    mid = (mid + Math.imul(al1, bh8)) | 0;\n    mid = (mid + Math.imul(ah1, bl8)) | 0;\n    hi = (hi + Math.imul(ah1, bh8)) | 0;\n    lo = (lo + Math.imul(al0, bl9)) | 0;\n    mid = (mid + Math.imul(al0, bh9)) | 0;\n    mid = (mid + Math.imul(ah0, bl9)) | 0;\n    hi = (hi + Math.imul(ah0, bh9)) | 0;\n    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n    w9 &= 0x3ffffff;\n    /* k = 10 */\n    lo = Math.imul(al9, bl1);\n    mid = Math.imul(al9, bh1);\n    mid = (mid + Math.imul(ah9, bl1)) | 0;\n    hi = Math.imul(ah9, bh1);\n    lo = (lo + Math.imul(al8, bl2)) | 0;\n    mid = (mid + Math.imul(al8, bh2)) | 0;\n    mid = (mid + Math.imul(ah8, bl2)) | 0;\n    hi = (hi + Math.imul(ah8, bh2)) | 0;\n    lo = (lo + Math.imul(al7, bl3)) | 0;\n    mid = (mid + Math.imul(al7, bh3)) | 0;\n    mid = (mid + Math.imul(ah7, bl3)) | 0;\n    hi = (hi + Math.imul(ah7, bh3)) | 0;\n    lo = (lo + Math.imul(al6, bl4)) | 0;\n    mid = (mid + Math.imul(al6, bh4)) | 0;\n    mid = (mid + Math.imul(ah6, bl4)) | 0;\n    hi = (hi + Math.imul(ah6, bh4)) | 0;\n    lo = (lo + Math.imul(al5, bl5)) | 0;\n    mid = (mid + Math.imul(al5, bh5)) | 0;\n    mid = (mid + Math.imul(ah5, bl5)) | 0;\n    hi = (hi + Math.imul(ah5, bh5)) | 0;\n    lo = (lo + Math.imul(al4, bl6)) | 0;\n    mid = (mid + Math.imul(al4, bh6)) | 0;\n    mid = (mid + Math.imul(ah4, bl6)) | 0;\n    hi = (hi + Math.imul(ah4, bh6)) | 0;\n    lo = (lo + Math.imul(al3, bl7)) | 0;\n    mid = (mid + Math.imul(al3, bh7)) | 0;\n    mid = (mid + Math.imul(ah3, bl7)) | 0;\n    hi = (hi + Math.imul(ah3, bh7)) | 0;\n    lo = (lo + Math.imul(al2, bl8)) | 0;\n    mid = (mid + Math.imul(al2, bh8)) | 0;\n    mid = (mid + Math.imul(ah2, bl8)) | 0;\n    hi = (hi + Math.imul(ah2, bh8)) | 0;\n    lo = (lo + Math.imul(al1, bl9)) | 0;\n    mid = (mid + Math.imul(al1, bh9)) | 0;\n    mid = (mid + Math.imul(ah1, bl9)) | 0;\n    hi = (hi + Math.imul(ah1, bh9)) | 0;\n    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n    w10 &= 0x3ffffff;\n    /* k = 11 */\n    lo = Math.imul(al9, bl2);\n    mid = Math.imul(al9, bh2);\n    mid = (mid + Math.imul(ah9, bl2)) | 0;\n    hi = Math.imul(ah9, bh2);\n    lo = (lo + Math.imul(al8, bl3)) | 0;\n    mid = (mid + Math.imul(al8, bh3)) | 0;\n    mid = (mid + Math.imul(ah8, bl3)) | 0;\n    hi = (hi + Math.imul(ah8, bh3)) | 0;\n    lo = (lo + Math.imul(al7, bl4)) | 0;\n    mid = (mid + Math.imul(al7, bh4)) | 0;\n    mid = (mid + Math.imul(ah7, bl4)) | 0;\n    hi = (hi + Math.imul(ah7, bh4)) | 0;\n    lo = (lo + Math.imul(al6, bl5)) | 0;\n    mid = (mid + Math.imul(al6, bh5)) | 0;\n    mid = (mid + Math.imul(ah6, bl5)) | 0;\n    hi = (hi + Math.imul(ah6, bh5)) | 0;\n    lo = (lo + Math.imul(al5, bl6)) | 0;\n    mid = (mid + Math.imul(al5, bh6)) | 0;\n    mid = (mid + Math.imul(ah5, bl6)) | 0;\n    hi = (hi + Math.imul(ah5, bh6)) | 0;\n    lo = (lo + Math.imul(al4, bl7)) | 0;\n    mid = (mid + Math.imul(al4, bh7)) | 0;\n    mid = (mid + Math.imul(ah4, bl7)) | 0;\n    hi = (hi + Math.imul(ah4, bh7)) | 0;\n    lo = (lo + Math.imul(al3, bl8)) | 0;\n    mid = (mid + Math.imul(al3, bh8)) | 0;\n    mid = (mid + Math.imul(ah3, bl8)) | 0;\n    hi = (hi + Math.imul(ah3, bh8)) | 0;\n    lo = (lo + Math.imul(al2, bl9)) | 0;\n    mid = (mid + Math.imul(al2, bh9)) | 0;\n    mid = (mid + Math.imul(ah2, bl9)) | 0;\n    hi = (hi + Math.imul(ah2, bh9)) | 0;\n    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n    w11 &= 0x3ffffff;\n    /* k = 12 */\n    lo = Math.imul(al9, bl3);\n    mid = Math.imul(al9, bh3);\n    mid = (mid + Math.imul(ah9, bl3)) | 0;\n    hi = Math.imul(ah9, bh3);\n    lo = (lo + Math.imul(al8, bl4)) | 0;\n    mid = (mid + Math.imul(al8, bh4)) | 0;\n    mid = (mid + Math.imul(ah8, bl4)) | 0;\n    hi = (hi + Math.imul(ah8, bh4)) | 0;\n    lo = (lo + Math.imul(al7, bl5)) | 0;\n    mid = (mid + Math.imul(al7, bh5)) | 0;\n    mid = (mid + Math.imul(ah7, bl5)) | 0;\n    hi = (hi + Math.imul(ah7, bh5)) | 0;\n    lo = (lo + Math.imul(al6, bl6)) | 0;\n    mid = (mid + Math.imul(al6, bh6)) | 0;\n    mid = (mid + Math.imul(ah6, bl6)) | 0;\n    hi = (hi + Math.imul(ah6, bh6)) | 0;\n    lo = (lo + Math.imul(al5, bl7)) | 0;\n    mid = (mid + Math.imul(al5, bh7)) | 0;\n    mid = (mid + Math.imul(ah5, bl7)) | 0;\n    hi = (hi + Math.imul(ah5, bh7)) | 0;\n    lo = (lo + Math.imul(al4, bl8)) | 0;\n    mid = (mid + Math.imul(al4, bh8)) | 0;\n    mid = (mid + Math.imul(ah4, bl8)) | 0;\n    hi = (hi + Math.imul(ah4, bh8)) | 0;\n    lo = (lo + Math.imul(al3, bl9)) | 0;\n    mid = (mid + Math.imul(al3, bh9)) | 0;\n    mid = (mid + Math.imul(ah3, bl9)) | 0;\n    hi = (hi + Math.imul(ah3, bh9)) | 0;\n    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n    w12 &= 0x3ffffff;\n    /* k = 13 */\n    lo = Math.imul(al9, bl4);\n    mid = Math.imul(al9, bh4);\n    mid = (mid + Math.imul(ah9, bl4)) | 0;\n    hi = Math.imul(ah9, bh4);\n    lo = (lo + Math.imul(al8, bl5)) | 0;\n    mid = (mid + Math.imul(al8, bh5)) | 0;\n    mid = (mid + Math.imul(ah8, bl5)) | 0;\n    hi = (hi + Math.imul(ah8, bh5)) | 0;\n    lo = (lo + Math.imul(al7, bl6)) | 0;\n    mid = (mid + Math.imul(al7, bh6)) | 0;\n    mid = (mid + Math.imul(ah7, bl6)) | 0;\n    hi = (hi + Math.imul(ah7, bh6)) | 0;\n    lo = (lo + Math.imul(al6, bl7)) | 0;\n    mid = (mid + Math.imul(al6, bh7)) | 0;\n    mid = (mid + Math.imul(ah6, bl7)) | 0;\n    hi = (hi + Math.imul(ah6, bh7)) | 0;\n    lo = (lo + Math.imul(al5, bl8)) | 0;\n    mid = (mid + Math.imul(al5, bh8)) | 0;\n    mid = (mid + Math.imul(ah5, bl8)) | 0;\n    hi = (hi + Math.imul(ah5, bh8)) | 0;\n    lo = (lo + Math.imul(al4, bl9)) | 0;\n    mid = (mid + Math.imul(al4, bh9)) | 0;\n    mid = (mid + Math.imul(ah4, bl9)) | 0;\n    hi = (hi + Math.imul(ah4, bh9)) | 0;\n    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n    w13 &= 0x3ffffff;\n    /* k = 14 */\n    lo = Math.imul(al9, bl5);\n    mid = Math.imul(al9, bh5);\n    mid = (mid + Math.imul(ah9, bl5)) | 0;\n    hi = Math.imul(ah9, bh5);\n    lo = (lo + Math.imul(al8, bl6)) | 0;\n    mid = (mid + Math.imul(al8, bh6)) | 0;\n    mid = (mid + Math.imul(ah8, bl6)) | 0;\n    hi = (hi + Math.imul(ah8, bh6)) | 0;\n    lo = (lo + Math.imul(al7, bl7)) | 0;\n    mid = (mid + Math.imul(al7, bh7)) | 0;\n    mid = (mid + Math.imul(ah7, bl7)) | 0;\n    hi = (hi + Math.imul(ah7, bh7)) | 0;\n    lo = (lo + Math.imul(al6, bl8)) | 0;\n    mid = (mid + Math.imul(al6, bh8)) | 0;\n    mid = (mid + Math.imul(ah6, bl8)) | 0;\n    hi = (hi + Math.imul(ah6, bh8)) | 0;\n    lo = (lo + Math.imul(al5, bl9)) | 0;\n    mid = (mid + Math.imul(al5, bh9)) | 0;\n    mid = (mid + Math.imul(ah5, bl9)) | 0;\n    hi = (hi + Math.imul(ah5, bh9)) | 0;\n    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n    w14 &= 0x3ffffff;\n    /* k = 15 */\n    lo = Math.imul(al9, bl6);\n    mid = Math.imul(al9, bh6);\n    mid = (mid + Math.imul(ah9, bl6)) | 0;\n    hi = Math.imul(ah9, bh6);\n    lo = (lo + Math.imul(al8, bl7)) | 0;\n    mid = (mid + Math.imul(al8, bh7)) | 0;\n    mid = (mid + Math.imul(ah8, bl7)) | 0;\n    hi = (hi + Math.imul(ah8, bh7)) | 0;\n    lo = (lo + Math.imul(al7, bl8)) | 0;\n    mid = (mid + Math.imul(al7, bh8)) | 0;\n    mid = (mid + Math.imul(ah7, bl8)) | 0;\n    hi = (hi + Math.imul(ah7, bh8)) | 0;\n    lo = (lo + Math.imul(al6, bl9)) | 0;\n    mid = (mid + Math.imul(al6, bh9)) | 0;\n    mid = (mid + Math.imul(ah6, bl9)) | 0;\n    hi = (hi + Math.imul(ah6, bh9)) | 0;\n    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n    w15 &= 0x3ffffff;\n    /* k = 16 */\n    lo = Math.imul(al9, bl7);\n    mid = Math.imul(al9, bh7);\n    mid = (mid + Math.imul(ah9, bl7)) | 0;\n    hi = Math.imul(ah9, bh7);\n    lo = (lo + Math.imul(al8, bl8)) | 0;\n    mid = (mid + Math.imul(al8, bh8)) | 0;\n    mid = (mid + Math.imul(ah8, bl8)) | 0;\n    hi = (hi + Math.imul(ah8, bh8)) | 0;\n    lo = (lo + Math.imul(al7, bl9)) | 0;\n    mid = (mid + Math.imul(al7, bh9)) | 0;\n    mid = (mid + Math.imul(ah7, bl9)) | 0;\n    hi = (hi + Math.imul(ah7, bh9)) | 0;\n    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n    w16 &= 0x3ffffff;\n    /* k = 17 */\n    lo = Math.imul(al9, bl8);\n    mid = Math.imul(al9, bh8);\n    mid = (mid + Math.imul(ah9, bl8)) | 0;\n    hi = Math.imul(ah9, bh8);\n    lo = (lo + Math.imul(al8, bl9)) | 0;\n    mid = (mid + Math.imul(al8, bh9)) | 0;\n    mid = (mid + Math.imul(ah8, bl9)) | 0;\n    hi = (hi + Math.imul(ah8, bh9)) | 0;\n    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n    w17 &= 0x3ffffff;\n    /* k = 18 */\n    lo = Math.imul(al9, bl9);\n    mid = Math.imul(al9, bh9);\n    mid = (mid + Math.imul(ah9, bl9)) | 0;\n    hi = Math.imul(ah9, bh9);\n    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n    w18 &= 0x3ffffff;\n    o[0] = w0;\n    o[1] = w1;\n    o[2] = w2;\n    o[3] = w3;\n    o[4] = w4;\n    o[5] = w5;\n    o[6] = w6;\n    o[7] = w7;\n    o[8] = w8;\n    o[9] = w9;\n    o[10] = w10;\n    o[11] = w11;\n    o[12] = w12;\n    o[13] = w13;\n    o[14] = w14;\n    o[15] = w15;\n    o[16] = w16;\n    o[17] = w17;\n    o[18] = w18;\n    if (c !== 0) {\n      o[19] = c;\n      out.length++;\n    }\n    return out;\n  };\n\n  // Polyfill comb\n  if (!Math.imul) {\n    comb10MulTo = smallMulTo;\n  }\n\n  function bigMulTo (self, num, out) {\n    out.negative = num.negative ^ self.negative;\n    out.length = self.length + num.length;\n\n    var carry = 0;\n    var hncarry = 0;\n    for (var k = 0; k < out.length - 1; k++) {\n      // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n      // note that ncarry could be >= 0x3ffffff\n      var ncarry = hncarry;\n      hncarry = 0;\n      var rword = carry & 0x3ffffff;\n      var maxJ = Math.min(k, num.length - 1);\n      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n        var i = k - j;\n        var a = self.words[i] | 0;\n        var b = num.words[j] | 0;\n        var r = a * b;\n\n        var lo = r & 0x3ffffff;\n        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n        lo = (lo + rword) | 0;\n        rword = lo & 0x3ffffff;\n        ncarry = (ncarry + (lo >>> 26)) | 0;\n\n        hncarry += ncarry >>> 26;\n        ncarry &= 0x3ffffff;\n      }\n      out.words[k] = rword;\n      carry = ncarry;\n      ncarry = hncarry;\n    }\n    if (carry !== 0) {\n      out.words[k] = carry;\n    } else {\n      out.length--;\n    }\n\n    return out._strip();\n  }\n\n  function jumboMulTo (self, num, out) {\n    // Temporary disable, see https://github.com/indutny/bn.js/issues/211\n    // var fftm = new FFTM();\n    // return fftm.mulp(self, num, out);\n    return bigMulTo(self, num, out);\n  }\n\n  BN.prototype.mulTo = function mulTo (num, out) {\n    var res;\n    var len = this.length + num.length;\n    if (this.length === 10 && num.length === 10) {\n      res = comb10MulTo(this, num, out);\n    } else if (len < 63) {\n      res = smallMulTo(this, num, out);\n    } else if (len < 1024) {\n      res = bigMulTo(this, num, out);\n    } else {\n      res = jumboMulTo(this, num, out);\n    }\n\n    return res;\n  };\n\n  // Cooley-Tukey algorithm for FFT\n  // slightly revisited to rely on looping instead of recursion\n\n  function FFTM (x, y) {\n    this.x = x;\n    this.y = y;\n  }\n\n  FFTM.prototype.makeRBT = function makeRBT (N) {\n    var t = new Array(N);\n    var l = BN.prototype._countBits(N) - 1;\n    for (var i = 0; i < N; i++) {\n      t[i] = this.revBin(i, l, N);\n    }\n\n    return t;\n  };\n\n  // Returns binary-reversed representation of `x`\n  FFTM.prototype.revBin = function revBin (x, l, N) {\n    if (x === 0 || x === N - 1) return x;\n\n    var rb = 0;\n    for (var i = 0; i < l; i++) {\n      rb |= (x & 1) << (l - i - 1);\n      x >>= 1;\n    }\n\n    return rb;\n  };\n\n  // Performs \"tweedling\" phase, therefore 'emulating'\n  // behaviour of the recursive algorithm\n  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n    for (var i = 0; i < N; i++) {\n      rtws[i] = rws[rbt[i]];\n      itws[i] = iws[rbt[i]];\n    }\n  };\n\n  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n    this.permute(rbt, rws, iws, rtws, itws, N);\n\n    for (var s = 1; s < N; s <<= 1) {\n      var l = s << 1;\n\n      var rtwdf = Math.cos(2 * Math.PI / l);\n      var itwdf = Math.sin(2 * Math.PI / l);\n\n      for (var p = 0; p < N; p += l) {\n        var rtwdf_ = rtwdf;\n        var itwdf_ = itwdf;\n\n        for (var j = 0; j < s; j++) {\n          var re = rtws[p + j];\n          var ie = itws[p + j];\n\n          var ro = rtws[p + j + s];\n          var io = itws[p + j + s];\n\n          var rx = rtwdf_ * ro - itwdf_ * io;\n\n          io = rtwdf_ * io + itwdf_ * ro;\n          ro = rx;\n\n          rtws[p + j] = re + ro;\n          itws[p + j] = ie + io;\n\n          rtws[p + j + s] = re - ro;\n          itws[p + j + s] = ie - io;\n\n          /* jshint maxdepth : false */\n          if (j !== l) {\n            rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n            rtwdf_ = rx;\n          }\n        }\n      }\n    }\n  };\n\n  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n    var N = Math.max(m, n) | 1;\n    var odd = N & 1;\n    var i = 0;\n    for (N = N / 2 | 0; N; N = N >>> 1) {\n      i++;\n    }\n\n    return 1 << i + 1 + odd;\n  };\n\n  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n    if (N <= 1) return;\n\n    for (var i = 0; i < N / 2; i++) {\n      var t = rws[i];\n\n      rws[i] = rws[N - i - 1];\n      rws[N - i - 1] = t;\n\n      t = iws[i];\n\n      iws[i] = -iws[N - i - 1];\n      iws[N - i - 1] = -t;\n    }\n  };\n\n  FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n    var carry = 0;\n    for (var i = 0; i < N / 2; i++) {\n      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n        Math.round(ws[2 * i] / N) +\n        carry;\n\n      ws[i] = w & 0x3ffffff;\n\n      if (w < 0x4000000) {\n        carry = 0;\n      } else {\n        carry = w / 0x4000000 | 0;\n      }\n    }\n\n    return ws;\n  };\n\n  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n    var carry = 0;\n    for (var i = 0; i < len; i++) {\n      carry = carry + (ws[i] | 0);\n\n      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n    }\n\n    // Pad with zeroes\n    for (i = 2 * len; i < N; ++i) {\n      rws[i] = 0;\n    }\n\n    assert(carry === 0);\n    assert((carry & ~0x1fff) === 0);\n  };\n\n  FFTM.prototype.stub = function stub (N) {\n    var ph = new Array(N);\n    for (var i = 0; i < N; i++) {\n      ph[i] = 0;\n    }\n\n    return ph;\n  };\n\n  FFTM.prototype.mulp = function mulp (x, y, out) {\n    var N = 2 * this.guessLen13b(x.length, y.length);\n\n    var rbt = this.makeRBT(N);\n\n    var _ = this.stub(N);\n\n    var rws = new Array(N);\n    var rwst = new Array(N);\n    var iwst = new Array(N);\n\n    var nrws = new Array(N);\n    var nrwst = new Array(N);\n    var niwst = new Array(N);\n\n    var rmws = out.words;\n    rmws.length = N;\n\n    this.convert13b(x.words, x.length, rws, N);\n    this.convert13b(y.words, y.length, nrws, N);\n\n    this.transform(rws, _, rwst, iwst, N, rbt);\n    this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n    for (var i = 0; i < N; i++) {\n      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n      rwst[i] = rx;\n    }\n\n    this.conjugate(rwst, iwst, N);\n    this.transform(rwst, iwst, rmws, _, N, rbt);\n    this.conjugate(rmws, _, N);\n    this.normalize13b(rmws, N);\n\n    out.negative = x.negative ^ y.negative;\n    out.length = x.length + y.length;\n    return out._strip();\n  };\n\n  // Multiply `this` by `num`\n  BN.prototype.mul = function mul (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return this.mulTo(num, out);\n  };\n\n  // Multiply employing FFT\n  BN.prototype.mulf = function mulf (num) {\n    var out = new BN(null);\n    out.words = new Array(this.length + num.length);\n    return jumboMulTo(this, num, out);\n  };\n\n  // In-place Multiplication\n  BN.prototype.imul = function imul (num) {\n    return this.clone().mulTo(num, this);\n  };\n\n  BN.prototype.imuln = function imuln (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n\n    // Carry\n    var carry = 0;\n    for (var i = 0; i < this.length; i++) {\n      var w = (this.words[i] | 0) * num;\n      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n      carry >>= 26;\n      carry += (w / 0x4000000) | 0;\n      // NOTE: lo is 27bit maximum\n      carry += lo >>> 26;\n      this.words[i] = lo & 0x3ffffff;\n    }\n\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n\n    return isNegNum ? this.ineg() : this;\n  };\n\n  BN.prototype.muln = function muln (num) {\n    return this.clone().imuln(num);\n  };\n\n  // `this` * `this`\n  BN.prototype.sqr = function sqr () {\n    return this.mul(this);\n  };\n\n  // `this` * `this` in-place\n  BN.prototype.isqr = function isqr () {\n    return this.imul(this.clone());\n  };\n\n  // Math.pow(`this`, `num`)\n  BN.prototype.pow = function pow (num) {\n    var w = toBitArray(num);\n    if (w.length === 0) return new BN(1);\n\n    // Skip leading zeroes\n    var res = this;\n    for (var i = 0; i < w.length; i++, res = res.sqr()) {\n      if (w[i] !== 0) break;\n    }\n\n    if (++i < w.length) {\n      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n        if (w[i] === 0) continue;\n\n        res = res.mul(q);\n      }\n    }\n\n    return res;\n  };\n\n  // Shift-left in-place\n  BN.prototype.iushln = function iushln (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n    var i;\n\n    if (r !== 0) {\n      var carry = 0;\n\n      for (i = 0; i < this.length; i++) {\n        var newCarry = this.words[i] & carryMask;\n        var c = ((this.words[i] | 0) - newCarry) << r;\n        this.words[i] = c | carry;\n        carry = newCarry >>> (26 - r);\n      }\n\n      if (carry) {\n        this.words[i] = carry;\n        this.length++;\n      }\n    }\n\n    if (s !== 0) {\n      for (i = this.length - 1; i >= 0; i--) {\n        this.words[i + s] = this.words[i];\n      }\n\n      for (i = 0; i < s; i++) {\n        this.words[i] = 0;\n      }\n\n      this.length += s;\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ishln = function ishln (bits) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushln(bits);\n  };\n\n  // Shift-right in-place\n  // NOTE: `hint` is a lowest bit before trailing zeroes\n  // NOTE: if `extended` is present - it will be filled with destroyed bits\n  BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var h;\n    if (hint) {\n      h = (hint - (hint % 26)) / 26;\n    } else {\n      h = 0;\n    }\n\n    var r = bits % 26;\n    var s = Math.min((bits - r) / 26, this.length);\n    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n    var maskedWords = extended;\n\n    h -= s;\n    h = Math.max(0, h);\n\n    // Extended mode, copy masked part\n    if (maskedWords) {\n      for (var i = 0; i < s; i++) {\n        maskedWords.words[i] = this.words[i];\n      }\n      maskedWords.length = s;\n    }\n\n    if (s === 0) {\n      // No-op, we should not move anything at all\n    } else if (this.length > s) {\n      this.length -= s;\n      for (i = 0; i < this.length; i++) {\n        this.words[i] = this.words[i + s];\n      }\n    } else {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    var carry = 0;\n    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n      var word = this.words[i] | 0;\n      this.words[i] = (carry << (26 - r)) | (word >>> r);\n      carry = word & mask;\n    }\n\n    // Push carried bits as a mask\n    if (maskedWords && carry !== 0) {\n      maskedWords.words[maskedWords.length++] = carry;\n    }\n\n    if (this.length === 0) {\n      this.words[0] = 0;\n      this.length = 1;\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n    // TODO(indutny): implement me\n    assert(this.negative === 0);\n    return this.iushrn(bits, hint, extended);\n  };\n\n  // Shift-left\n  BN.prototype.shln = function shln (bits) {\n    return this.clone().ishln(bits);\n  };\n\n  BN.prototype.ushln = function ushln (bits) {\n    return this.clone().iushln(bits);\n  };\n\n  // Shift-right\n  BN.prototype.shrn = function shrn (bits) {\n    return this.clone().ishrn(bits);\n  };\n\n  BN.prototype.ushrn = function ushrn (bits) {\n    return this.clone().iushrn(bits);\n  };\n\n  // Test if n bit is set\n  BN.prototype.testn = function testn (bit) {\n    assert(typeof bit === 'number' && bit >= 0);\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) return false;\n\n    // Check bit and return\n    var w = this.words[s];\n\n    return !!(w & q);\n  };\n\n  // Return only lowers bits of number (in-place)\n  BN.prototype.imaskn = function imaskn (bits) {\n    assert(typeof bits === 'number' && bits >= 0);\n    var r = bits % 26;\n    var s = (bits - r) / 26;\n\n    assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n    if (this.length <= s) {\n      return this;\n    }\n\n    if (r !== 0) {\n      s++;\n    }\n    this.length = Math.min(s, this.length);\n\n    if (r !== 0) {\n      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n      this.words[this.length - 1] &= mask;\n    }\n\n    return this._strip();\n  };\n\n  // Return only lowers bits of number\n  BN.prototype.maskn = function maskn (bits) {\n    return this.clone().imaskn(bits);\n  };\n\n  // Add plain number `num` to `this`\n  BN.prototype.iaddn = function iaddn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.isubn(-num);\n\n    // Possible sign change\n    if (this.negative !== 0) {\n      if (this.length === 1 && (this.words[0] | 0) <= num) {\n        this.words[0] = num - (this.words[0] | 0);\n        this.negative = 0;\n        return this;\n      }\n\n      this.negative = 0;\n      this.isubn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    // Add without checks\n    return this._iaddn(num);\n  };\n\n  BN.prototype._iaddn = function _iaddn (num) {\n    this.words[0] += num;\n\n    // Carry\n    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n      this.words[i] -= 0x4000000;\n      if (i === this.length - 1) {\n        this.words[i + 1] = 1;\n      } else {\n        this.words[i + 1]++;\n      }\n    }\n    this.length = Math.max(this.length, i + 1);\n\n    return this;\n  };\n\n  // Subtract plain number `num` from `this`\n  BN.prototype.isubn = function isubn (num) {\n    assert(typeof num === 'number');\n    assert(num < 0x4000000);\n    if (num < 0) return this.iaddn(-num);\n\n    if (this.negative !== 0) {\n      this.negative = 0;\n      this.iaddn(num);\n      this.negative = 1;\n      return this;\n    }\n\n    this.words[0] -= num;\n\n    if (this.length === 1 && this.words[0] < 0) {\n      this.words[0] = -this.words[0];\n      this.negative = 1;\n    } else {\n      // Carry\n      for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n        this.words[i] += 0x4000000;\n        this.words[i + 1] -= 1;\n      }\n    }\n\n    return this._strip();\n  };\n\n  BN.prototype.addn = function addn (num) {\n    return this.clone().iaddn(num);\n  };\n\n  BN.prototype.subn = function subn (num) {\n    return this.clone().isubn(num);\n  };\n\n  BN.prototype.iabs = function iabs () {\n    this.negative = 0;\n\n    return this;\n  };\n\n  BN.prototype.abs = function abs () {\n    return this.clone().iabs();\n  };\n\n  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n    var len = num.length + shift;\n    var i;\n\n    this._expand(len);\n\n    var w;\n    var carry = 0;\n    for (i = 0; i < num.length; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      var right = (num.words[i] | 0) * mul;\n      w -= right & 0x3ffffff;\n      carry = (w >> 26) - ((right / 0x4000000) | 0);\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n    for (; i < this.length - shift; i++) {\n      w = (this.words[i + shift] | 0) + carry;\n      carry = w >> 26;\n      this.words[i + shift] = w & 0x3ffffff;\n    }\n\n    if (carry === 0) return this._strip();\n\n    // Subtraction overflow\n    assert(carry === -1);\n    carry = 0;\n    for (i = 0; i < this.length; i++) {\n      w = -(this.words[i] | 0) + carry;\n      carry = w >> 26;\n      this.words[i] = w & 0x3ffffff;\n    }\n    this.negative = 1;\n\n    return this._strip();\n  };\n\n  BN.prototype._wordDiv = function _wordDiv (num, mode) {\n    var shift = this.length - num.length;\n\n    var a = this.clone();\n    var b = num;\n\n    // Normalize\n    var bhi = b.words[b.length - 1] | 0;\n    var bhiBits = this._countBits(bhi);\n    shift = 26 - bhiBits;\n    if (shift !== 0) {\n      b = b.ushln(shift);\n      a.iushln(shift);\n      bhi = b.words[b.length - 1] | 0;\n    }\n\n    // Initialize quotient\n    var m = a.length - b.length;\n    var q;\n\n    if (mode !== 'mod') {\n      q = new BN(null);\n      q.length = m + 1;\n      q.words = new Array(q.length);\n      for (var i = 0; i < q.length; i++) {\n        q.words[i] = 0;\n      }\n    }\n\n    var diff = a.clone()._ishlnsubmul(b, 1, m);\n    if (diff.negative === 0) {\n      a = diff;\n      if (q) {\n        q.words[m] = 1;\n      }\n    }\n\n    for (var j = m - 1; j >= 0; j--) {\n      var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n        (a.words[b.length + j - 1] | 0);\n\n      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n      // (0x7ffffff)\n      qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n      a._ishlnsubmul(b, qj, j);\n      while (a.negative !== 0) {\n        qj--;\n        a.negative = 0;\n        a._ishlnsubmul(b, 1, j);\n        if (!a.isZero()) {\n          a.negative ^= 1;\n        }\n      }\n      if (q) {\n        q.words[j] = qj;\n      }\n    }\n    if (q) {\n      q._strip();\n    }\n    a._strip();\n\n    // Denormalize\n    if (mode !== 'div' && shift !== 0) {\n      a.iushrn(shift);\n    }\n\n    return {\n      div: q || null,\n      mod: a\n    };\n  };\n\n  // NOTE: 1) `mode` can be set to `mod` to request mod only,\n  //       to `div` to request div only, or be absent to\n  //       request both div & mod\n  //       2) `positive` is true if unsigned mod is requested\n  BN.prototype.divmod = function divmod (num, mode, positive) {\n    assert(!num.isZero());\n\n    if (this.isZero()) {\n      return {\n        div: new BN(0),\n        mod: new BN(0)\n      };\n    }\n\n    var div, mod, res;\n    if (this.negative !== 0 && num.negative === 0) {\n      res = this.neg().divmod(num, mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.iadd(num);\n        }\n      }\n\n      return {\n        div: div,\n        mod: mod\n      };\n    }\n\n    if (this.negative === 0 && num.negative !== 0) {\n      res = this.divmod(num.neg(), mode);\n\n      if (mode !== 'mod') {\n        div = res.div.neg();\n      }\n\n      return {\n        div: div,\n        mod: res.mod\n      };\n    }\n\n    if ((this.negative & num.negative) !== 0) {\n      res = this.neg().divmod(num.neg(), mode);\n\n      if (mode !== 'div') {\n        mod = res.mod.neg();\n        if (positive && mod.negative !== 0) {\n          mod.isub(num);\n        }\n      }\n\n      return {\n        div: res.div,\n        mod: mod\n      };\n    }\n\n    // Both numbers are positive at this point\n\n    // Strip both numbers to approximate shift value\n    if (num.length > this.length || this.cmp(num) < 0) {\n      return {\n        div: new BN(0),\n        mod: this\n      };\n    }\n\n    // Very short reduction\n    if (num.length === 1) {\n      if (mode === 'div') {\n        return {\n          div: this.divn(num.words[0]),\n          mod: null\n        };\n      }\n\n      if (mode === 'mod') {\n        return {\n          div: null,\n          mod: new BN(this.modrn(num.words[0]))\n        };\n      }\n\n      return {\n        div: this.divn(num.words[0]),\n        mod: new BN(this.modrn(num.words[0]))\n      };\n    }\n\n    return this._wordDiv(num, mode);\n  };\n\n  // Find `this` / `num`\n  BN.prototype.div = function div (num) {\n    return this.divmod(num, 'div', false).div;\n  };\n\n  // Find `this` % `num`\n  BN.prototype.mod = function mod (num) {\n    return this.divmod(num, 'mod', false).mod;\n  };\n\n  BN.prototype.umod = function umod (num) {\n    return this.divmod(num, 'mod', true).mod;\n  };\n\n  // Find Round(`this` / `num`)\n  BN.prototype.divRound = function divRound (num) {\n    var dm = this.divmod(num);\n\n    // Fast case - exact division\n    if (dm.mod.isZero()) return dm.div;\n\n    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n    var half = num.ushrn(1);\n    var r2 = num.andln(1);\n    var cmp = mod.cmp(half);\n\n    // Round down\n    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;\n\n    // Round up\n    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n  };\n\n  BN.prototype.modrn = function modrn (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(num <= 0x3ffffff);\n    var p = (1 << 26) % num;\n\n    var acc = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      acc = (p * acc + (this.words[i] | 0)) % num;\n    }\n\n    return isNegNum ? -acc : acc;\n  };\n\n  // WARNING: DEPRECATED\n  BN.prototype.modn = function modn (num) {\n    return this.modrn(num);\n  };\n\n  // In-place division by number\n  BN.prototype.idivn = function idivn (num) {\n    var isNegNum = num < 0;\n    if (isNegNum) num = -num;\n\n    assert(num <= 0x3ffffff);\n\n    var carry = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var w = (this.words[i] | 0) + carry * 0x4000000;\n      this.words[i] = (w / num) | 0;\n      carry = w % num;\n    }\n\n    this._strip();\n    return isNegNum ? this.ineg() : this;\n  };\n\n  BN.prototype.divn = function divn (num) {\n    return this.clone().idivn(num);\n  };\n\n  BN.prototype.egcd = function egcd (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var x = this;\n    var y = p.clone();\n\n    if (x.negative !== 0) {\n      x = x.umod(p);\n    } else {\n      x = x.clone();\n    }\n\n    // A * x + B * y = x\n    var A = new BN(1);\n    var B = new BN(0);\n\n    // C * x + D * y = y\n    var C = new BN(0);\n    var D = new BN(1);\n\n    var g = 0;\n\n    while (x.isEven() && y.isEven()) {\n      x.iushrn(1);\n      y.iushrn(1);\n      ++g;\n    }\n\n    var yp = y.clone();\n    var xp = x.clone();\n\n    while (!x.isZero()) {\n      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        x.iushrn(i);\n        while (i-- > 0) {\n          if (A.isOdd() || B.isOdd()) {\n            A.iadd(yp);\n            B.isub(xp);\n          }\n\n          A.iushrn(1);\n          B.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        y.iushrn(j);\n        while (j-- > 0) {\n          if (C.isOdd() || D.isOdd()) {\n            C.iadd(yp);\n            D.isub(xp);\n          }\n\n          C.iushrn(1);\n          D.iushrn(1);\n        }\n      }\n\n      if (x.cmp(y) >= 0) {\n        x.isub(y);\n        A.isub(C);\n        B.isub(D);\n      } else {\n        y.isub(x);\n        C.isub(A);\n        D.isub(B);\n      }\n    }\n\n    return {\n      a: C,\n      b: D,\n      gcd: y.iushln(g)\n    };\n  };\n\n  // This is reduced incarnation of the binary EEA\n  // above, designated to invert members of the\n  // _prime_ fields F(p) at a maximal speed\n  BN.prototype._invmp = function _invmp (p) {\n    assert(p.negative === 0);\n    assert(!p.isZero());\n\n    var a = this;\n    var b = p.clone();\n\n    if (a.negative !== 0) {\n      a = a.umod(p);\n    } else {\n      a = a.clone();\n    }\n\n    var x1 = new BN(1);\n    var x2 = new BN(0);\n\n    var delta = b.clone();\n\n    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n      if (i > 0) {\n        a.iushrn(i);\n        while (i-- > 0) {\n          if (x1.isOdd()) {\n            x1.iadd(delta);\n          }\n\n          x1.iushrn(1);\n        }\n      }\n\n      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n      if (j > 0) {\n        b.iushrn(j);\n        while (j-- > 0) {\n          if (x2.isOdd()) {\n            x2.iadd(delta);\n          }\n\n          x2.iushrn(1);\n        }\n      }\n\n      if (a.cmp(b) >= 0) {\n        a.isub(b);\n        x1.isub(x2);\n      } else {\n        b.isub(a);\n        x2.isub(x1);\n      }\n    }\n\n    var res;\n    if (a.cmpn(1) === 0) {\n      res = x1;\n    } else {\n      res = x2;\n    }\n\n    if (res.cmpn(0) < 0) {\n      res.iadd(p);\n    }\n\n    return res;\n  };\n\n  BN.prototype.gcd = function gcd (num) {\n    if (this.isZero()) return num.abs();\n    if (num.isZero()) return this.abs();\n\n    var a = this.clone();\n    var b = num.clone();\n    a.negative = 0;\n    b.negative = 0;\n\n    // Remove common factor of two\n    for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n      a.iushrn(1);\n      b.iushrn(1);\n    }\n\n    do {\n      while (a.isEven()) {\n        a.iushrn(1);\n      }\n      while (b.isEven()) {\n        b.iushrn(1);\n      }\n\n      var r = a.cmp(b);\n      if (r < 0) {\n        // Swap `a` and `b` to make `a` always bigger than `b`\n        var t = a;\n        a = b;\n        b = t;\n      } else if (r === 0 || b.cmpn(1) === 0) {\n        break;\n      }\n\n      a.isub(b);\n    } while (true);\n\n    return b.iushln(shift);\n  };\n\n  // Invert number in the field F(num)\n  BN.prototype.invm = function invm (num) {\n    return this.egcd(num).a.umod(num);\n  };\n\n  BN.prototype.isEven = function isEven () {\n    return (this.words[0] & 1) === 0;\n  };\n\n  BN.prototype.isOdd = function isOdd () {\n    return (this.words[0] & 1) === 1;\n  };\n\n  // And first word and num\n  BN.prototype.andln = function andln (num) {\n    return this.words[0] & num;\n  };\n\n  // Increment at the bit position in-line\n  BN.prototype.bincn = function bincn (bit) {\n    assert(typeof bit === 'number');\n    var r = bit % 26;\n    var s = (bit - r) / 26;\n    var q = 1 << r;\n\n    // Fast case: bit is much higher than all existing words\n    if (this.length <= s) {\n      this._expand(s + 1);\n      this.words[s] |= q;\n      return this;\n    }\n\n    // Add bit and propagate, if needed\n    var carry = q;\n    for (var i = s; carry !== 0 && i < this.length; i++) {\n      var w = this.words[i] | 0;\n      w += carry;\n      carry = w >>> 26;\n      w &= 0x3ffffff;\n      this.words[i] = w;\n    }\n    if (carry !== 0) {\n      this.words[i] = carry;\n      this.length++;\n    }\n    return this;\n  };\n\n  BN.prototype.isZero = function isZero () {\n    return this.length === 1 && this.words[0] === 0;\n  };\n\n  BN.prototype.cmpn = function cmpn (num) {\n    var negative = num < 0;\n\n    if (this.negative !== 0 && !negative) return -1;\n    if (this.negative === 0 && negative) return 1;\n\n    this._strip();\n\n    var res;\n    if (this.length > 1) {\n      res = 1;\n    } else {\n      if (negative) {\n        num = -num;\n      }\n\n      assert(num <= 0x3ffffff, 'Number is too big');\n\n      var w = this.words[0] | 0;\n      res = w === num ? 0 : w < num ? -1 : 1;\n    }\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Compare two numbers and return:\n  // 1 - if `this` > `num`\n  // 0 - if `this` == `num`\n  // -1 - if `this` < `num`\n  BN.prototype.cmp = function cmp (num) {\n    if (this.negative !== 0 && num.negative === 0) return -1;\n    if (this.negative === 0 && num.negative !== 0) return 1;\n\n    var res = this.ucmp(num);\n    if (this.negative !== 0) return -res | 0;\n    return res;\n  };\n\n  // Unsigned comparison\n  BN.prototype.ucmp = function ucmp (num) {\n    // At this point both numbers have the same sign\n    if (this.length > num.length) return 1;\n    if (this.length < num.length) return -1;\n\n    var res = 0;\n    for (var i = this.length - 1; i >= 0; i--) {\n      var a = this.words[i] | 0;\n      var b = num.words[i] | 0;\n\n      if (a === b) continue;\n      if (a < b) {\n        res = -1;\n      } else if (a > b) {\n        res = 1;\n      }\n      break;\n    }\n    return res;\n  };\n\n  BN.prototype.gtn = function gtn (num) {\n    return this.cmpn(num) === 1;\n  };\n\n  BN.prototype.gt = function gt (num) {\n    return this.cmp(num) === 1;\n  };\n\n  BN.prototype.gten = function gten (num) {\n    return this.cmpn(num) >= 0;\n  };\n\n  BN.prototype.gte = function gte (num) {\n    return this.cmp(num) >= 0;\n  };\n\n  BN.prototype.ltn = function ltn (num) {\n    return this.cmpn(num) === -1;\n  };\n\n  BN.prototype.lt = function lt (num) {\n    return this.cmp(num) === -1;\n  };\n\n  BN.prototype.lten = function lten (num) {\n    return this.cmpn(num) <= 0;\n  };\n\n  BN.prototype.lte = function lte (num) {\n    return this.cmp(num) <= 0;\n  };\n\n  BN.prototype.eqn = function eqn (num) {\n    return this.cmpn(num) === 0;\n  };\n\n  BN.prototype.eq = function eq (num) {\n    return this.cmp(num) === 0;\n  };\n\n  //\n  // A reduce context, could be using montgomery or something better, depending\n  // on the `m` itself.\n  //\n  BN.red = function red (num) {\n    return new Red(num);\n  };\n\n  BN.prototype.toRed = function toRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    assert(this.negative === 0, 'red works only with positives');\n    return ctx.convertTo(this)._forceRed(ctx);\n  };\n\n  BN.prototype.fromRed = function fromRed () {\n    assert(this.red, 'fromRed works only with numbers in reduction context');\n    return this.red.convertFrom(this);\n  };\n\n  BN.prototype._forceRed = function _forceRed (ctx) {\n    this.red = ctx;\n    return this;\n  };\n\n  BN.prototype.forceRed = function forceRed (ctx) {\n    assert(!this.red, 'Already a number in reduction context');\n    return this._forceRed(ctx);\n  };\n\n  BN.prototype.redAdd = function redAdd (num) {\n    assert(this.red, 'redAdd works only with red numbers');\n    return this.red.add(this, num);\n  };\n\n  BN.prototype.redIAdd = function redIAdd (num) {\n    assert(this.red, 'redIAdd works only with red numbers');\n    return this.red.iadd(this, num);\n  };\n\n  BN.prototype.redSub = function redSub (num) {\n    assert(this.red, 'redSub works only with red numbers');\n    return this.red.sub(this, num);\n  };\n\n  BN.prototype.redISub = function redISub (num) {\n    assert(this.red, 'redISub works only with red numbers');\n    return this.red.isub(this, num);\n  };\n\n  BN.prototype.redShl = function redShl (num) {\n    assert(this.red, 'redShl works only with red numbers');\n    return this.red.shl(this, num);\n  };\n\n  BN.prototype.redMul = function redMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.mul(this, num);\n  };\n\n  BN.prototype.redIMul = function redIMul (num) {\n    assert(this.red, 'redMul works only with red numbers');\n    this.red._verify2(this, num);\n    return this.red.imul(this, num);\n  };\n\n  BN.prototype.redSqr = function redSqr () {\n    assert(this.red, 'redSqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqr(this);\n  };\n\n  BN.prototype.redISqr = function redISqr () {\n    assert(this.red, 'redISqr works only with red numbers');\n    this.red._verify1(this);\n    return this.red.isqr(this);\n  };\n\n  // Square root over p\n  BN.prototype.redSqrt = function redSqrt () {\n    assert(this.red, 'redSqrt works only with red numbers');\n    this.red._verify1(this);\n    return this.red.sqrt(this);\n  };\n\n  BN.prototype.redInvm = function redInvm () {\n    assert(this.red, 'redInvm works only with red numbers');\n    this.red._verify1(this);\n    return this.red.invm(this);\n  };\n\n  // Return negative clone of `this` % `red modulo`\n  BN.prototype.redNeg = function redNeg () {\n    assert(this.red, 'redNeg works only with red numbers');\n    this.red._verify1(this);\n    return this.red.neg(this);\n  };\n\n  BN.prototype.redPow = function redPow (num) {\n    assert(this.red && !num.red, 'redPow(normalNum)');\n    this.red._verify1(this);\n    return this.red.pow(this, num);\n  };\n\n  // Prime numbers with efficient reduction\n  var primes = {\n    k256: null,\n    p224: null,\n    p192: null,\n    p25519: null\n  };\n\n  // Pseudo-Mersenne prime\n  function MPrime (name, p) {\n    // P = 2 ^ N - K\n    this.name = name;\n    this.p = new BN(p, 16);\n    this.n = this.p.bitLength();\n    this.k = new BN(1).iushln(this.n).isub(this.p);\n\n    this.tmp = this._tmp();\n  }\n\n  MPrime.prototype._tmp = function _tmp () {\n    var tmp = new BN(null);\n    tmp.words = new Array(Math.ceil(this.n / 13));\n    return tmp;\n  };\n\n  MPrime.prototype.ireduce = function ireduce (num) {\n    // Assumes that `num` is less than `P^2`\n    // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n    var r = num;\n    var rlen;\n\n    do {\n      this.split(r, this.tmp);\n      r = this.imulK(r);\n      r = r.iadd(this.tmp);\n      rlen = r.bitLength();\n    } while (rlen > this.n);\n\n    var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n    if (cmp === 0) {\n      r.words[0] = 0;\n      r.length = 1;\n    } else if (cmp > 0) {\n      r.isub(this.p);\n    } else {\n      if (r.strip !== undefined) {\n        // r is a BN v4 instance\n        r.strip();\n      } else {\n        // r is a BN v5 instance\n        r._strip();\n      }\n    }\n\n    return r;\n  };\n\n  MPrime.prototype.split = function split (input, out) {\n    input.iushrn(this.n, 0, out);\n  };\n\n  MPrime.prototype.imulK = function imulK (num) {\n    return num.imul(this.k);\n  };\n\n  function K256 () {\n    MPrime.call(\n      this,\n      'k256',\n      'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n  }\n  inherits(K256, MPrime);\n\n  K256.prototype.split = function split (input, output) {\n    // 256 = 9 * 26 + 22\n    var mask = 0x3fffff;\n\n    var outLen = Math.min(input.length, 9);\n    for (var i = 0; i < outLen; i++) {\n      output.words[i] = input.words[i];\n    }\n    output.length = outLen;\n\n    if (input.length <= 9) {\n      input.words[0] = 0;\n      input.length = 1;\n      return;\n    }\n\n    // Shift by 9 limbs\n    var prev = input.words[9];\n    output.words[output.length++] = prev & mask;\n\n    for (i = 10; i < input.length; i++) {\n      var next = input.words[i] | 0;\n      input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n      prev = next;\n    }\n    prev >>>= 22;\n    input.words[i - 10] = prev;\n    if (prev === 0 && input.length > 10) {\n      input.length -= 10;\n    } else {\n      input.length -= 9;\n    }\n  };\n\n  K256.prototype.imulK = function imulK (num) {\n    // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n    num.words[num.length] = 0;\n    num.words[num.length + 1] = 0;\n    num.length += 2;\n\n    // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n    var lo = 0;\n    for (var i = 0; i < num.length; i++) {\n      var w = num.words[i] | 0;\n      lo += w * 0x3d1;\n      num.words[i] = lo & 0x3ffffff;\n      lo = w * 0x40 + ((lo / 0x4000000) | 0);\n    }\n\n    // Fast length reduction\n    if (num.words[num.length - 1] === 0) {\n      num.length--;\n      if (num.words[num.length - 1] === 0) {\n        num.length--;\n      }\n    }\n    return num;\n  };\n\n  function P224 () {\n    MPrime.call(\n      this,\n      'p224',\n      'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n  }\n  inherits(P224, MPrime);\n\n  function P192 () {\n    MPrime.call(\n      this,\n      'p192',\n      'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n  }\n  inherits(P192, MPrime);\n\n  function P25519 () {\n    // 2 ^ 255 - 19\n    MPrime.call(\n      this,\n      '25519',\n      '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n  }\n  inherits(P25519, MPrime);\n\n  P25519.prototype.imulK = function imulK (num) {\n    // K = 0x13\n    var carry = 0;\n    for (var i = 0; i < num.length; i++) {\n      var hi = (num.words[i] | 0) * 0x13 + carry;\n      var lo = hi & 0x3ffffff;\n      hi >>>= 26;\n\n      num.words[i] = lo;\n      carry = hi;\n    }\n    if (carry !== 0) {\n      num.words[num.length++] = carry;\n    }\n    return num;\n  };\n\n  // Exported mostly for testing purposes, use plain name instead\n  BN._prime = function prime (name) {\n    // Cached version of prime\n    if (primes[name]) return primes[name];\n\n    var prime;\n    if (name === 'k256') {\n      prime = new K256();\n    } else if (name === 'p224') {\n      prime = new P224();\n    } else if (name === 'p192') {\n      prime = new P192();\n    } else if (name === 'p25519') {\n      prime = new P25519();\n    } else {\n      throw new Error('Unknown prime ' + name);\n    }\n    primes[name] = prime;\n\n    return prime;\n  };\n\n  //\n  // Base reduction engine\n  //\n  function Red (m) {\n    if (typeof m === 'string') {\n      var prime = BN._prime(m);\n      this.m = prime.p;\n      this.prime = prime;\n    } else {\n      assert(m.gtn(1), 'modulus must be greater than 1');\n      this.m = m;\n      this.prime = null;\n    }\n  }\n\n  Red.prototype._verify1 = function _verify1 (a) {\n    assert(a.negative === 0, 'red works only with positives');\n    assert(a.red, 'red works only with red numbers');\n  };\n\n  Red.prototype._verify2 = function _verify2 (a, b) {\n    assert((a.negative | b.negative) === 0, 'red works only with positives');\n    assert(a.red && a.red === b.red,\n      'red works only with red numbers');\n  };\n\n  Red.prototype.imod = function imod (a) {\n    if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n\n    move(a, a.umod(this.m)._forceRed(this));\n    return a;\n  };\n\n  Red.prototype.neg = function neg (a) {\n    if (a.isZero()) {\n      return a.clone();\n    }\n\n    return this.m.sub(a)._forceRed(this);\n  };\n\n  Red.prototype.add = function add (a, b) {\n    this._verify2(a, b);\n\n    var res = a.add(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.iadd = function iadd (a, b) {\n    this._verify2(a, b);\n\n    var res = a.iadd(b);\n    if (res.cmp(this.m) >= 0) {\n      res.isub(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.sub = function sub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.sub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res._forceRed(this);\n  };\n\n  Red.prototype.isub = function isub (a, b) {\n    this._verify2(a, b);\n\n    var res = a.isub(b);\n    if (res.cmpn(0) < 0) {\n      res.iadd(this.m);\n    }\n    return res;\n  };\n\n  Red.prototype.shl = function shl (a, num) {\n    this._verify1(a);\n    return this.imod(a.ushln(num));\n  };\n\n  Red.prototype.imul = function imul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.imul(b));\n  };\n\n  Red.prototype.mul = function mul (a, b) {\n    this._verify2(a, b);\n    return this.imod(a.mul(b));\n  };\n\n  Red.prototype.isqr = function isqr (a) {\n    return this.imul(a, a.clone());\n  };\n\n  Red.prototype.sqr = function sqr (a) {\n    return this.mul(a, a);\n  };\n\n  Red.prototype.sqrt = function sqrt (a) {\n    if (a.isZero()) return a.clone();\n\n    var mod3 = this.m.andln(3);\n    assert(mod3 % 2 === 1);\n\n    // Fast case\n    if (mod3 === 3) {\n      var pow = this.m.add(new BN(1)).iushrn(2);\n      return this.pow(a, pow);\n    }\n\n    // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n    //\n    // Find Q and S, that Q * 2 ^ S = (P - 1)\n    var q = this.m.subn(1);\n    var s = 0;\n    while (!q.isZero() && q.andln(1) === 0) {\n      s++;\n      q.iushrn(1);\n    }\n    assert(!q.isZero());\n\n    var one = new BN(1).toRed(this);\n    var nOne = one.redNeg();\n\n    // Find quadratic non-residue\n    // NOTE: Max is such because of generalized Riemann hypothesis.\n    var lpow = this.m.subn(1).iushrn(1);\n    var z = this.m.bitLength();\n    z = new BN(2 * z * z).toRed(this);\n\n    while (this.pow(z, lpow).cmp(nOne) !== 0) {\n      z.redIAdd(nOne);\n    }\n\n    var c = this.pow(z, q);\n    var r = this.pow(a, q.addn(1).iushrn(1));\n    var t = this.pow(a, q);\n    var m = s;\n    while (t.cmp(one) !== 0) {\n      var tmp = t;\n      for (var i = 0; tmp.cmp(one) !== 0; i++) {\n        tmp = tmp.redSqr();\n      }\n      assert(i < m);\n      var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n      r = r.redMul(b);\n      c = b.redSqr();\n      t = t.redMul(c);\n      m = i;\n    }\n\n    return r;\n  };\n\n  Red.prototype.invm = function invm (a) {\n    var inv = a._invmp(this.m);\n    if (inv.negative !== 0) {\n      inv.negative = 0;\n      return this.imod(inv).redNeg();\n    } else {\n      return this.imod(inv);\n    }\n  };\n\n  Red.prototype.pow = function pow (a, num) {\n    if (num.isZero()) return new BN(1).toRed(this);\n    if (num.cmpn(1) === 0) return a.clone();\n\n    var windowSize = 4;\n    var wnd = new Array(1 << windowSize);\n    wnd[0] = new BN(1).toRed(this);\n    wnd[1] = a;\n    for (var i = 2; i < wnd.length; i++) {\n      wnd[i] = this.mul(wnd[i - 1], a);\n    }\n\n    var res = wnd[0];\n    var current = 0;\n    var currentLen = 0;\n    var start = num.bitLength() % 26;\n    if (start === 0) {\n      start = 26;\n    }\n\n    for (i = num.length - 1; i >= 0; i--) {\n      var word = num.words[i];\n      for (var j = start - 1; j >= 0; j--) {\n        var bit = (word >> j) & 1;\n        if (res !== wnd[0]) {\n          res = this.sqr(res);\n        }\n\n        if (bit === 0 && current === 0) {\n          currentLen = 0;\n          continue;\n        }\n\n        current <<= 1;\n        current |= bit;\n        currentLen++;\n        if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n        res = this.mul(res, wnd[current]);\n        currentLen = 0;\n        current = 0;\n      }\n      start = 26;\n    }\n\n    return res;\n  };\n\n  Red.prototype.convertTo = function convertTo (num) {\n    var r = num.umod(this.m);\n\n    return r === num ? r.clone() : r;\n  };\n\n  Red.prototype.convertFrom = function convertFrom (num) {\n    var res = num.clone();\n    res.red = null;\n    return res;\n  };\n\n  //\n  // Montgomery method engine\n  //\n\n  BN.mont = function mont (num) {\n    return new Mont(num);\n  };\n\n  function Mont (m) {\n    Red.call(this, m);\n\n    this.shift = this.m.bitLength();\n    if (this.shift % 26 !== 0) {\n      this.shift += 26 - (this.shift % 26);\n    }\n\n    this.r = new BN(1).iushln(this.shift);\n    this.r2 = this.imod(this.r.sqr());\n    this.rinv = this.r._invmp(this.m);\n\n    this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n    this.minv = this.minv.umod(this.r);\n    this.minv = this.r.sub(this.minv);\n  }\n  inherits(Mont, Red);\n\n  Mont.prototype.convertTo = function convertTo (num) {\n    return this.imod(num.ushln(this.shift));\n  };\n\n  Mont.prototype.convertFrom = function convertFrom (num) {\n    var r = this.imod(num.mul(this.rinv));\n    r.red = null;\n    return r;\n  };\n\n  Mont.prototype.imul = function imul (a, b) {\n    if (a.isZero() || b.isZero()) {\n      a.words[0] = 0;\n      a.length = 1;\n      return a;\n    }\n\n    var t = a.imul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.mul = function mul (a, b) {\n    if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n    var t = a.mul(b);\n    var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n    var u = t.isub(c).iushrn(this.shift);\n    var res = u;\n    if (u.cmp(this.m) >= 0) {\n      res = u.isub(this.m);\n    } else if (u.cmpn(0) < 0) {\n      res = u.iadd(this.m);\n    }\n\n    return res._forceRed(this);\n  };\n\n  Mont.prototype.invm = function invm (a) {\n    // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n    var res = this.imod(a._invmp(this.m).mul(this.r2));\n    return res._forceRed(this);\n  };\n})(typeof module === 'undefined' || module, this);\n","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar eos;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\nvar _require$codes = require('../../../errors').codes,\n  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true;\n\n    // request.destroy just do .end - .abort is what we want\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\nfunction call(fn) {\n  fn();\n}\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\nmodule.exports = pipeline;","'use strict';\n\n// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer;\nvar createHmac = require('create-hmac');\nvar crt = require('browserify-rsa');\nvar EC = require('elliptic').ec;\nvar BN = require('bn.js');\nvar parseKeys = require('parse-asn1');\nvar curves = require('./curves.json');\n\nvar RSA_PKCS1_PADDING = 1;\n\nfunction sign(hash, key, hashType, signType, tag) {\n  var priv = parseKeys(key);\n  if (priv.curve) {\n    // rsa keys can be interpreted as ecdsa ones in openssl\n    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') { throw new Error('wrong private key type'); }\n    return ecSign(hash, priv);\n  } else if (priv.type === 'dsa') {\n    if (signType !== 'dsa') { throw new Error('wrong private key type'); }\n    return dsaSign(hash, priv, hashType);\n  }\n  if (signType !== 'rsa' && signType !== 'ecdsa/rsa') { throw new Error('wrong private key type'); }\n  if (key.padding !== undefined && key.padding !== RSA_PKCS1_PADDING) { throw new Error('illegal or unsupported padding mode'); }\n\n  hash = Buffer.concat([tag, hash]);\n  var len = priv.modulus.byteLength();\n  var pad = [0, 1];\n  while (hash.length + pad.length + 1 < len) { pad.push(0xff); }\n  pad.push(0x00);\n  var i = -1;\n  while (++i < hash.length) { pad.push(hash[i]); }\n\n  var out = crt(pad, priv);\n  return out;\n}\n\nfunction ecSign(hash, priv) {\n  var curveId = curves[priv.curve.join('.')];\n  if (!curveId) { throw new Error('unknown curve ' + priv.curve.join('.')); }\n\n  var curve = new EC(curveId);\n  var key = curve.keyFromPrivate(priv.privateKey);\n  var out = key.sign(hash);\n\n  return Buffer.from(out.toDER());\n}\n\nfunction dsaSign(hash, priv, algo) {\n  var x = priv.params.priv_key;\n  var p = priv.params.p;\n  var q = priv.params.q;\n  var g = priv.params.g;\n  var r = new BN(0);\n  var k;\n  var H = bits2int(hash, q).mod(q);\n  var s = false;\n  var kv = getKey(x, q, hash, algo);\n  while (s === false) {\n    k = makeKey(q, kv, algo);\n    r = makeR(g, k, p, q);\n    s = k.invm(q).imul(H.add(x.mul(r))).mod(q);\n    if (s.cmpn(0) === 0) {\n      s = false;\n      r = new BN(0);\n    }\n  }\n  return toDER(r, s);\n}\n\nfunction toDER(r, s) {\n  r = r.toArray();\n  s = s.toArray();\n\n  // Pad values\n  if (r[0] & 0x80) { r = [0].concat(r); }\n  if (s[0] & 0x80) { s = [0].concat(s); }\n\n  var total = r.length + s.length + 4;\n  var res = [\n    0x30, total, 0x02, r.length\n  ];\n  res = res.concat(r, [0x02, s.length], s);\n  return Buffer.from(res);\n}\n\nfunction getKey(x, q, hash, algo) {\n  x = Buffer.from(x.toArray());\n  if (x.length < q.byteLength()) {\n    var zeros = Buffer.alloc(q.byteLength() - x.length);\n    x = Buffer.concat([zeros, x]);\n  }\n  var hlen = hash.length;\n  var hbits = bits2octets(hash, q);\n  var v = Buffer.alloc(hlen);\n  v.fill(1);\n  var k = Buffer.alloc(hlen);\n  k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest();\n  v = createHmac(algo, k).update(v).digest();\n  k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest();\n  v = createHmac(algo, k).update(v).digest();\n  return { k: k, v: v };\n}\n\nfunction bits2int(obits, q) {\n  var bits = new BN(obits);\n  var shift = (obits.length << 3) - q.bitLength();\n  if (shift > 0) { bits.ishrn(shift); }\n  return bits;\n}\n\nfunction bits2octets(bits, q) {\n  bits = bits2int(bits, q);\n  bits = bits.mod(q);\n  var out = Buffer.from(bits.toArray());\n  if (out.length < q.byteLength()) {\n    var zeros = Buffer.alloc(q.byteLength() - out.length);\n    out = Buffer.concat([zeros, out]);\n  }\n  return out;\n}\n\nfunction makeKey(q, kv, algo) {\n  var t;\n  var k;\n\n  do {\n    t = Buffer.alloc(0);\n\n    while (t.length * 8 < q.bitLength()) {\n      kv.v = createHmac(algo, kv.k).update(kv.v).digest();\n      t = Buffer.concat([t, kv.v]);\n    }\n\n    k = bits2int(t, q);\n    kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest();\n    kv.v = createHmac(algo, kv.k).update(kv.v).digest();\n  } while (k.cmp(q) !== -1);\n\n  return k;\n}\n\nfunction makeR(g, k, p, q) {\n  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q);\n}\n\nmodule.exports = sign;\nmodule.exports.getKey = getKey;\nmodule.exports.makeKey = makeKey;\n"],"sourceRoot":""}