{"version":3,"sources":["webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/state.js","webpack:///./node_modules/browserify-sign/algos.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/browserify-sign/browser/sign.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/browserify-sign/browser/verify.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:///./node_modules/browserify-sign/browser/index.js","webpack:///./node_modules/browserify-sign/node_modules/bn.js/lib/bn.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/errors-browser.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/from-browser.js"],"names":["ERR_INVALID_OPT_VALUE","codes","module","exports","getHighWaterMark","state","options","duplexKey","isDuplex","hwm","highWaterMark","highWaterMarkFrom","isFinite","Math","floor","objectMode","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_defineProperty","obj","key","value","defineProperty","configurable","writable","_defineProperties","target","props","i","length","descriptor","Buffer","inspect","custom","copyBuffer","src","offset","prototype","copy","call","BufferList","instance","Constructor","TypeError","_classCallCheck","this","head","tail","protoProps","staticProps","_createClass","v","entry","data","next","ret","s","p","n","alloc","allocUnsafe","hasStrings","slice","shift","_getString","_getBuffer","c","str","nb","buf","_","arguments","source","forEach","getOwnPropertyDescriptors","defineProperties","_objectSpread","depth","customInspect","Stream","Readable","Writable","Duplex","Transform","PassThrough","finished","pipeline","ERR_STREAM_PREMATURE_CLOSE","noop","eos","stream","opts","callback","called","_len","args","Array","_key","once","readable","onlegacyfinish","onfinish","writableEnded","_writableState","readableEnded","_readableState","endEmitted","onend","onerror","err","onclose","ended","onrequest","req","on","setHeader","abort","isRequest","error","removeListener","CorkedRequest","_this","finish","corkReq","cb","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","OurUint8Array","global","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","destroyed","noDecode","decodeStrings","defaultEncoding","writing","corked","sync","bufferProcessing","onwrite","er","writecb","writelen","bufferedRequest","lastBufferedRequest","prefinished","errorEmitted","emitClose","autoDestroy","bufferedRequestCount","write","_write","writev","_writev","destroy","_destroy","final","_final","writeAfterEnd","process","nextTick","validChunk","chunk","decodeChunk","encoding","from","doWrite","len","onwriteStateUpdate","finishMaybe","onwriteError","needFinish","clearBuffer","afterWrite","emit","onwriteDrain","l","buffer","holder","count","allBuffers","isBuf","callFinal","prefinish","need","rState","endWritable","getBuffer","current","out","get","Symbol","hasInstance","Function","pipe","isBuffer","_isUint8Array","_uint8ArrayToBuffer","newChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","toLowerCase","indexOf","end","set","_undestroy","undestroy","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","done","readAndResolve","iter","resolve","read","onReadable","AsyncIteratorPrototype","getPrototypeOf","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","Promise","reject","undefined","promise","lastPromise","then","wrapForNext","asyncIterator","_this2","_Object$create","iterator","create","code","bind","objectKeys","method","allowHalfOpen","onEndNT","self","createHmac","crt","EC","ec","BN","parseKeys","curves","ecSign","hash","priv","curveId","curve","join","Error","keyFromPrivate","privateKey","sign","toDER","dsaSign","algo","k","x","params","priv_key","q","g","r","H","bits2int","mod","kv","getKey","makeR","makeKey","invm","imul","add","mul","cmpn","toArray","concat","res","byteLength","zeros","hlen","hbits","bits","bits2octets","fill","update","digest","obits","bitLength","ishrn","t","cmp","toRed","mont","redPow","fromRed","hashType","signType","tag","type","modulus","pad","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","reading","wState","ecVerify","sig","pub","algorithm","pubkey","subjectPrivateKey","verify","dsaVerify","y","pub_key","unpacked","signature","decode","checkValue","montp","w","b","padNum","red","publicExponent","min","_transform","ERR_MISSING_ARGS","destroyer","closed","fn","to","popCallback","streams","pop","isArray","destroys","map","reduce","createHash","inherits","algorithms","Sign","_hashType","_hash","_tag","id","_signType","Verify","createSign","createVerify","enc","toString","assert","val","msg","ctor","superCtor","super_","TempCtor","constructor","number","base","endian","isBN","negative","words","_init","wordSize","window","e","parseHex4Bits","string","index","charCodeAt","parseHexByte","lowerBound","parseBase","start","move","dest","num","max","left","right","_initNumber","_initArray","replace","_parseHex","_parseBase","ceil","j","off","_strip","limbLen","limbPow","total","word","imuln","_iaddn","pow","_move","clone","_expand","size","_normSign","for","groupSizes","groupBases","padding","carry","groupSize","groupBase","isZero","modrn","idivn","toNumber","toJSON","toBuffer","toArrayLike","smallMulTo","a","lo","ncarry","rword","maxJ","ArrayType","reqLength","allocate","_toArrayLikeLE","position","_toArrayLikeBE","clz32","_countBits","_zeroBits","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","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","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","transform","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","carryMask","newCarry","ishln","iushrn","hint","extended","h","mask","maskedWords","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","name","tmp","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","split","imulK","strip","input","output","outLen","prev","mod3","one","nOne","lpow","z","inv","wnd","currentLen","u","ReadableState","EventEmitter","EElistenerCount","emitter","listeners","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","ERR_STREAM_PUSH_AFTER_EOF","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","kProxyEvents","readableObjectMode","pipes","pipesCount","flowing","needReadable","emittedReadable","readableListening","resumeScheduled","paused","awaitDrain","readingMore","decoder","_read","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","chunkInvalid","addChunk","maybeReadMore","unshift","isPaused","setEncoding","content","clear","MAX_HWM","howMuchToRead","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","listenerCount","resume","nReadingNextTick","resume_","fromList","first","consume","endReadable","endReadableNT","xs","parseInt","nOrig","doRead","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","ondrain","pipeOnDrain","cleanedUp","ondata","pause","event","prependListener","_events","dests","splice","ev","addListener","removeAllListeners","wrap","_fromList","iterable","createErrorType","message","Base","getMessage","arg1","arg2","arg3","NodeError","_Base","subClass","superClass","__proto__","_inheritsLoose","oneOf","expected","thing","String","actual","determiner","search","pos","substr","startsWith","this_len","substring","endsWith","includes","arg","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","flush","_flush","err2"],"mappings":"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","file":"js/chunk-vendors~41d44f25.ece7f5b2.js","sourcesContent":["'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\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\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","module.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); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\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, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\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\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\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\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\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\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\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","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\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\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\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\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\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}\n\nmodule.exports = eos;","// 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// 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'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\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;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // 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\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // 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\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // 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\n  this.sync = true; // 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\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\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})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\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}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // 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  // 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  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\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); // legacy.\n\n  this.writable = true;\n\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\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\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.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\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\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\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};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\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};\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});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n\n  return chunk;\n}\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}); // 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.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n  if (!ret) state.needDrain = true;\n\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\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\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}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\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); // this can emit finish, and it will always happen\n    // after error\n\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); // this can emit finish, but finish must\n    // always follow error\n\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\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\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\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} // 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.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\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\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\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--; // 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\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\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\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\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});\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\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}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\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\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\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');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\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}\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\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\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    } // 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\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\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\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\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\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\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\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\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]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\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// 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'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\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}\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\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\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}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\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\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  } else {\n    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')\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 = [0x30, total, 0x02, r.length]\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","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\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\n    return this;\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\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\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\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\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}\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\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}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\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  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}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\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  } else {\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++\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) >= q) throw new Error('invalid sig')\n}\n\nmodule.exports = verify\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\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}\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;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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; // request.destroy just do .end - .abort is what we want\n\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}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\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}\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\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\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}\n\nmodule.exports = pipeline;","var 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  if (typeof data === 'string') data = Buffer.from(data, enc)\n\n  this._hash.update(data)\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  if (typeof data === 'string') data = Buffer.from(data, enc)\n\n  this._hash.update(data)\n  return this\n}\n\nVerify.prototype.verify = function verifyMethod (key, sig, enc) {\n  if (typeof sig === 'string') sig = Buffer.from(sig, enc)\n\n  this.end()\n  var hash = this._hash.digest()\n  return verify(sig, 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","(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        if (carry !== 0 || i !== this.length - 1) {\n          out = zeros[6 - word.length] + word + out;\n        } else {\n          out = word + out;\n        }\n        off += 2;\n        if (off >= 26) {\n          off -= 26;\n          i--;\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","// 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'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\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; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\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); // 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\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}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // 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\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; // 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\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\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}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\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\n  Stream.call(this);\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\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.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\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\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\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\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  } // 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\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\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\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\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\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\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\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\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  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\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; // 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\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  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\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  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\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; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // 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\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\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\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; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\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\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\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.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\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\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\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.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\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) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\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.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\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\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\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\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\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; // 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\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\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\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\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  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\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\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\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; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\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\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\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}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\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; // Try start flowing on next tick if stream isn't explicitly paused\n\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\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\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\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\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\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\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; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\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.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\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); // don't skip over falsy values in objectMode\n\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\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  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\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}); // exposed for testing purposes only.\n\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}); // 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.\n\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}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\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\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\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\n    return from(Readable, iterable, opts);\n  };\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\n  return -1;\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 = require('events').EventEmitter;\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// 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'use strict';\n\nmodule.exports = Transform;\n\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;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // 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\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\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  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // 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\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\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}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\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.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\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\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}; // 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.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\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};\n\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // 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\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}","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n"],"sourceRoot":""}