{"version":3,"sources":["webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/randombytes/browser.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/rlp/dist.browser/index.js","webpack:///./node_modules/randomfill/browser.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/readable-stream/node_modules/safe-buffer/index.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/ripemd160/index.js","webpack:///./node_modules/rlp/node_modules/bn.js/lib/bn.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/readable-stream/readable-browser.js"],"names":["module","exports","MAX_BYTES","Buffer","crypto","global","msCrypto","getRandomValues","size","cb","RangeError","bytes","allocUnsafe","generated","slice","process","nextTick","Error","Transform","Duplex","util","Object","create","afterTransform","er","data","ts","this","_transformState","transforming","writecb","emit","writechunk","push","rs","_readableState","reading","needReadable","length","highWaterMark","_read","options","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","EventEmitter","pna","emitErrorNT","self","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","undestroy","ended","endEmitted","ending","finished","copyBuffer","src","target","offset","copy","BufferList","instance","Constructor","TypeError","_classCallCheck","head","tail","v","entry","next","unshift","shift","ret","clear","join","s","p","concat","alloc","i","inspect","custom","obj","constructor","name","MapShim","Map","getIndex","arr","key","result","some","index","class_1","__entries__","defineProperty","get","enumerable","configurable","set","value","delete","entries","splice","has","forEach","callback","ctx","_i","_a","isBrowser","window","document","global$1","Math","Function","requestAnimationFrame$1","requestAnimationFrame","setTimeout","Date","now","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","addObserver","observer","indexOf","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","addEventListener","observe","attributes","childList","characterData","subtree","removeEventListener","disconnect","_b","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","props","keys","writable","getWindowOf","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","arguments","reduce","position","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","paddings","positions_1","getPaddings","horizPad","left","right","vertPad","top","bottom","width","height","boxSizing","round","documentElement","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","getBBox","getContentRect","bbox","getSVGContentRect","x","y","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","rect","broadcastRect","ResizeObserverEntry","rectInit","contentRect","Constr","DOMRectReadOnly","createReadOnlyRect","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","observation","map","WeakMap","ResizeObserver","method","apply","__importDefault","mod","__esModule","getLength","decode","encode","bn_js_1","safeParseInt","base","parseInt","encodeLength","len","from","hexLength","intToHex","firstByte","_decode","input","llength","innerRemainder","d","decoded","remainder","toString","totalLength","isHexPrefixed","str","integer","hex","toBuffer","isBuffer","a","padToEven","stripHexPrefix","intToBuffer","Uint8Array","default","isBN","toArray","Array","isArray","output","buf","inputBuf","inputBuffer","oldBrowser","safeBuffer","randombytes","kBufferMaxLength","kMaxLength","kMaxUint32","pow","assertOffset","assertSize","actualFill","browser","ourBuf","buffer","uint","randomFill","randomFillSync","PassThrough","undefined","Op","hasOwn","hasOwnProperty","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","inModule","runtime","regeneratorRuntime","wrap","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","GeneratorFunctionPrototype","Generator","GeneratorFunction","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","arg","__await","defineIteratorMethods","AsyncIterator","async","innerFn","outerFn","tryLocsList","iter","then","object","reverse","pop","Context","reset","skipTempReset","prev","sent","_sent","delegate","tryEntries","resetTryEntry","charAt","isNaN","stop","rootRecord","completion","type","rval","dispatchException","exception","context","handle","loc","caught","record","tryLoc","hasCatch","hasFinally","catchLoc","finallyLoc","abrupt","finallyEntry","complete","afterLoc","finish","thrown","delegateYield","iterable","resultName","nextLoc","protoGenerator","generator","_invoke","state","doneResult","delegateResult","maybeInvokeDelegate","tryCatch","makeInvokeMethod","fn","invoke","resolve","reject","Promise","unwrapped","previousPromise","callInvokeWithMethodAndArg","return","info","pushTryEntry","locs","iteratorMethod","copyProps","dst","SafeBuffer","encodingOrOffset","allocUnsafeSlow","fill","SlowBuffer","Readable","ReadableState","EElistenerCount","emitter","listeners","Stream","OurUint8Array","debugUtil","debug","debuglog","StringDecoder","destroyImpl","kProxyEvents","prependListener","event","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","floor","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readable","read","readableAddChunk","addToFront","skipChunkCheck","end","emitReadable","onEofChunk","_isUint8Array","chunkInvalid","_uint8ArrayToBuffer","addChunk","write","maybeReadMore","needMoreData","_undestroy","isPaused","setEncoding","enc","MAX_HWM","howMuchToRead","computeNewHighWaterMark","emitReadable_","flow","maybeReadMore_","nReadingNextTick","resume_","fromList","list","hasStrings","c","nb","copyFromBufferString","copyFromBuffer","fromListPartial","endReadable","endReadableNT","xs","l","nOrig","doRead","pipe","dest","pipeOpts","endFn","stdout","stderr","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","pipeOnDrain","cleanedUp","removeListener","onclose","onfinish","onerror","ondata","needDrain","increasedAwaitDrain","pause","resume","dests","ev","res","addListener","paused","_fromList","objectKeys","Writable","allowHalfOpen","onEndNT","HashBase","ARRAY16","zl","zr","sl","sr","hl","hr","RIPEMD160","_c","_d","_e","rotl","fn1","b","e","m","k","fn2","fn3","fn4","fn5","_update","words","j","_block","readInt32LE","al","bl","cl","dl","el","ar","br","cr","dr","tl","tr","t","_digest","_blockOffset","writeUInt32LE","_length","writeInt32LE","assert","val","msg","superCtor","super_","TempCtor","BN","number","endian","negative","red","_init","wordSize","parseHex4Bits","string","charCodeAt","parseHexByte","lowerBound","r","parseBase","start","mul","min","move","num","max","cmp","_initNumber","_initArray","replace","_parseHex","_parseBase","ceil","w","off","_strip","limbLen","limbPow","total","word","imuln","_iaddn","_move","clone","_expand","_normSign","for","zeros","groupSizes","groupBases","padding","out","carry","groupSize","groupBase","isZero","modrn","idivn","toNumber","toJSON","toArrayLike","smallMulTo","lo","ncarry","rword","maxJ","ArrayType","byteLength","reqLength","allocate","_toArrayLikeLE","_toArrayLikeBE","clz32","_countBits","_zeroBits","bitLength","hi","zeroBits","toTwos","inotn","iaddn","fromTwos","testn","notn","ineg","isNeg","neg","iuor","ior","or","uor","iuand","iand","and","uand","iuxor","ixor","xor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","add","sub","comb10MulTo","mid","o","a0","al0","ah0","a1","al1","ah1","a2","al2","ah2","a3","al3","ah3","a4","al4","ah4","a5","al5","ah5","a6","al6","ah6","a7","al7","ah7","a8","al8","ah8","a9","al9","ah9","b0","bl0","bh0","b1","bl1","bh1","b2","bl2","bh2","b3","bl3","bh3","b4","bl4","bh4","b5","bl5","bh5","b6","bl6","bh6","b7","bl7","bh7","b8","bl8","bh8","b9","bl9","bh9","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","bigMulTo","hncarry","jumboMulTo","FFTM","mulTo","makeRBT","N","revBin","rb","permute","rbt","rws","iws","rtws","itws","rtwdf","cos","PI","itwdf","sin","rtwdf_","itwdf_","re","ie","ro","io","rx","guessLen13b","odd","conjugate","normalize13b","ws","convert13b","stub","ph","mulp","_","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","isNegNum","muln","sqr","isqr","toBitArray","q","iushln","bits","carryMask","newCarry","ishln","iushrn","hint","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","div","divmod","positive","divn","umod","divRound","dm","half","r2","andln","acc","modn","egcd","A","B","C","D","g","isEven","yp","xp","im","isOdd","jm","gcd","_invmp","x1","x2","delta","cmpn","invm","bincn","ucmp","gtn","gt","gten","gte","ltn","lt","lten","lte","eqn","eq","Red","toRed","convertTo","_forceRed","fromRed","convertFrom","forceRed","redAdd","redIAdd","redSub","redISub","redShl","shl","redMul","_verify2","redIMul","redSqr","_verify1","redISqr","redSqrt","sqrt","redInvm","redNeg","redPow","primes","k256","p224","p192","p25519","MPrime","tmp","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","split","imulK","strip","outLen","mod3","one","nOne","lpow","z","inv","wnd","current","currentLen","mont","u","CorkedRequest","corkReq","pendingcb","corkedRequestsFree","onCorkedFinish","asyncWrite","version","setImmediate","WritableState","internalUtil","deprecate","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","prefinished","bufferedRequestCount","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","writeOrBuffer","isBuf","newChunk","decodeChunk","last","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","getBuffer","hasInstance","cork","uncork","setDefaultEncoding","toLowerCase","endWritable"],"mappings":"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","file":"js/chunk-vendors~fd731fb0.4aa30e6c.js","sourcesContent":["module.exports = require('./lib/_stream_duplex.js');\n","'use strict'\n\n// limit of Crypto.getRandomValues()\n// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\nvar MAX_BYTES = 65536\n\n// Node supports requesting up to this number of bytes\n// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48\nvar MAX_UINT32 = 4294967295\n\nfunction oldBrowser () {\n  throw new Error('Secure random number generation is not supported by this browser.\\nUse Chrome, Firefox or Internet Explorer 11')\n}\n\nvar Buffer = require('safe-buffer').Buffer\nvar crypto = global.crypto || global.msCrypto\n\nif (crypto && crypto.getRandomValues) {\n  module.exports = randomBytes\n} else {\n  module.exports = oldBrowser\n}\n\nfunction randomBytes (size, cb) {\n  // phantomjs needs to throw\n  if (size > MAX_UINT32) throw new RangeError('requested too many random bytes')\n\n  var bytes = Buffer.allocUnsafe(size)\n\n  if (size > 0) {  // getRandomValues fails on IE if size == 0\n    if (size > MAX_BYTES) { // this is the max bytes crypto.getRandomValues\n      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues\n      for (var generated = 0; generated < size; generated += MAX_BYTES) {\n        // buffer.slice automatically checks if the end is past the end of\n        // the buffer so we don't have to here\n        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES))\n      }\n    } else {\n      crypto.getRandomValues(bytes)\n    }\n  }\n\n  if (typeof cb === 'function') {\n    return process.nextTick(function () {\n      cb(null, bytes)\n    })\n  }\n\n  return bytes\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\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\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\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};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\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  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","module.exports = require('./lib/_stream_writable.js');\n","module.exports = require('events').EventEmitter;\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\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 && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\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.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = 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  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getLength = exports.decode = exports.encode = void 0;\nvar bn_js_1 = __importDefault(require(\"bn.js\"));\n/**\n * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\n * This function takes in a data, convert it to buffer if not, and a length for recursion\n * @param input - will be converted to buffer\n * @returns returns buffer of encoded data\n **/\nfunction encode(input) {\n    if (Array.isArray(input)) {\n        var output = [];\n        for (var i = 0; i < input.length; i++) {\n            output.push(encode(input[i]));\n        }\n        var buf = Buffer.concat(output);\n        return Buffer.concat([encodeLength(buf.length, 192), buf]);\n    }\n    else {\n        var inputBuf = toBuffer(input);\n        return inputBuf.length === 1 && inputBuf[0] < 128\n            ? inputBuf\n            : Buffer.concat([encodeLength(inputBuf.length, 128), inputBuf]);\n    }\n}\nexports.encode = encode;\n/**\n * Parse integers. Check if there is no leading zeros\n * @param v The value to parse\n * @param base The base to parse the integer into\n */\nfunction safeParseInt(v, base) {\n    if (v[0] === '0' && v[1] === '0') {\n        throw new Error('invalid RLP: extra zeros');\n    }\n    return parseInt(v, base);\n}\nfunction encodeLength(len, offset) {\n    if (len < 56) {\n        return Buffer.from([len + offset]);\n    }\n    else {\n        var hexLength = intToHex(len);\n        var lLength = hexLength.length / 2;\n        var firstByte = intToHex(offset + 55 + lLength);\n        return Buffer.from(firstByte + hexLength, 'hex');\n    }\n}\nfunction decode(input, stream) {\n    if (stream === void 0) { stream = false; }\n    if (!input || input.length === 0) {\n        return Buffer.from([]);\n    }\n    var inputBuffer = toBuffer(input);\n    var decoded = _decode(inputBuffer);\n    if (stream) {\n        return decoded;\n    }\n    if (decoded.remainder.length !== 0) {\n        throw new Error('invalid remainder');\n    }\n    return decoded.data;\n}\nexports.decode = decode;\n/**\n * Get the length of the RLP input\n * @param input\n * @returns The length of the input or an empty Buffer if no input\n */\nfunction getLength(input) {\n    if (!input || input.length === 0) {\n        return Buffer.from([]);\n    }\n    var inputBuffer = toBuffer(input);\n    var firstByte = inputBuffer[0];\n    if (firstByte <= 0x7f) {\n        return inputBuffer.length;\n    }\n    else if (firstByte <= 0xb7) {\n        return firstByte - 0x7f;\n    }\n    else if (firstByte <= 0xbf) {\n        return firstByte - 0xb6;\n    }\n    else if (firstByte <= 0xf7) {\n        // a list between  0-55 bytes long\n        return firstByte - 0xbf;\n    }\n    else {\n        // a list  over 55 bytes long\n        var llength = firstByte - 0xf6;\n        var length_1 = safeParseInt(inputBuffer.slice(1, llength).toString('hex'), 16);\n        return llength + length_1;\n    }\n}\nexports.getLength = getLength;\n/** Decode an input with RLP */\nfunction _decode(input) {\n    var length, llength, data, innerRemainder, d;\n    var decoded = [];\n    var firstByte = input[0];\n    if (firstByte <= 0x7f) {\n        // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.\n        return {\n            data: input.slice(0, 1),\n            remainder: input.slice(1),\n        };\n    }\n    else if (firstByte <= 0xb7) {\n        // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string\n        // The range of the first byte is [0x80, 0xb7]\n        length = firstByte - 0x7f;\n        // set 0x80 null to 0\n        if (firstByte === 0x80) {\n            data = Buffer.from([]);\n        }\n        else {\n            data = input.slice(1, length);\n        }\n        if (length === 2 && data[0] < 0x80) {\n            throw new Error('invalid rlp encoding: byte must be less 0x80');\n        }\n        return {\n            data: data,\n            remainder: input.slice(length),\n        };\n    }\n    else if (firstByte <= 0xbf) {\n        // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),\n        // followed by the length, followed by the string\n        llength = firstByte - 0xb6;\n        if (input.length - 1 < llength) {\n            throw new Error('invalid RLP: not enough bytes for string length');\n        }\n        length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n        if (length <= 55) {\n            throw new Error('invalid RLP: expected string length to be greater than 55');\n        }\n        data = input.slice(llength, length + llength);\n        if (data.length < length) {\n            throw new Error('invalid RLP: not enough bytes for string');\n        }\n        return {\n            data: data,\n            remainder: input.slice(length + llength),\n        };\n    }\n    else if (firstByte <= 0xf7) {\n        // a list between  0-55 bytes long\n        length = firstByte - 0xbf;\n        innerRemainder = input.slice(1, length);\n        while (innerRemainder.length) {\n            d = _decode(innerRemainder);\n            decoded.push(d.data);\n            innerRemainder = d.remainder;\n        }\n        return {\n            data: decoded,\n            remainder: input.slice(length),\n        };\n    }\n    else {\n        // a list  over 55 bytes long\n        llength = firstByte - 0xf6;\n        length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n        var totalLength = llength + length;\n        if (totalLength > input.length) {\n            throw new Error('invalid rlp: total length is larger than the data');\n        }\n        innerRemainder = input.slice(llength, totalLength);\n        if (innerRemainder.length === 0) {\n            throw new Error('invalid rlp, List has a invalid length');\n        }\n        while (innerRemainder.length) {\n            d = _decode(innerRemainder);\n            decoded.push(d.data);\n            innerRemainder = d.remainder;\n        }\n        return {\n            data: decoded,\n            remainder: input.slice(totalLength),\n        };\n    }\n}\n/** Check if a string is prefixed by 0x */\nfunction isHexPrefixed(str) {\n    return str.slice(0, 2) === '0x';\n}\n/** Removes 0x from a given String */\nfunction stripHexPrefix(str) {\n    if (typeof str !== 'string') {\n        return str;\n    }\n    return isHexPrefixed(str) ? str.slice(2) : str;\n}\n/** Transform an integer into its hexadecimal value */\nfunction intToHex(integer) {\n    if (integer < 0) {\n        throw new Error('Invalid integer as argument, must be unsigned!');\n    }\n    var hex = integer.toString(16);\n    return hex.length % 2 ? \"0\" + hex : hex;\n}\n/** Pad a string to be even */\nfunction padToEven(a) {\n    return a.length % 2 ? \"0\" + a : a;\n}\n/** Transform an integer into a Buffer */\nfunction intToBuffer(integer) {\n    var hex = intToHex(integer);\n    return Buffer.from(hex, 'hex');\n}\n/** Transform anything into a Buffer */\nfunction toBuffer(v) {\n    if (!Buffer.isBuffer(v)) {\n        if (typeof v === 'string') {\n            if (isHexPrefixed(v)) {\n                return Buffer.from(padToEven(stripHexPrefix(v)), 'hex');\n            }\n            else {\n                return Buffer.from(v);\n            }\n        }\n        else if (typeof v === 'number' || typeof v === 'bigint') {\n            if (!v) {\n                return Buffer.from([]);\n            }\n            else {\n                return intToBuffer(v);\n            }\n        }\n        else if (v === null || v === undefined) {\n            return Buffer.from([]);\n        }\n        else if (v instanceof Uint8Array) {\n            return Buffer.from(v);\n        }\n        else if (bn_js_1.default.isBN(v)) {\n            // converts a BN to a Buffer\n            return Buffer.from(v.toArray());\n        }\n        else {\n            throw new Error('invalid type');\n        }\n    }\n    return v;\n}\n//# sourceMappingURL=index.js.map","'use strict'\n\nfunction oldBrowser () {\n  throw new Error('secure random number generation not supported by this browser\\nuse chrome, FireFox or Internet Explorer 11')\n}\nvar safeBuffer = require('safe-buffer')\nvar randombytes = require('randombytes')\nvar Buffer = safeBuffer.Buffer\nvar kBufferMaxLength = safeBuffer.kMaxLength\nvar crypto = global.crypto || global.msCrypto\nvar kMaxUint32 = Math.pow(2, 32) - 1\nfunction assertOffset (offset, length) {\n  if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare\n    throw new TypeError('offset must be a number')\n  }\n\n  if (offset > kMaxUint32 || offset < 0) {\n    throw new TypeError('offset must be a uint32')\n  }\n\n  if (offset > kBufferMaxLength || offset > length) {\n    throw new RangeError('offset out of range')\n  }\n}\n\nfunction assertSize (size, offset, length) {\n  if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare\n    throw new TypeError('size must be a number')\n  }\n\n  if (size > kMaxUint32 || size < 0) {\n    throw new TypeError('size must be a uint32')\n  }\n\n  if (size + offset > length || size > kBufferMaxLength) {\n    throw new RangeError('buffer too small')\n  }\n}\nif ((crypto && crypto.getRandomValues) || !process.browser) {\n  exports.randomFill = randomFill\n  exports.randomFillSync = randomFillSync\n} else {\n  exports.randomFill = oldBrowser\n  exports.randomFillSync = oldBrowser\n}\nfunction randomFill (buf, offset, size, cb) {\n  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n    throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n  }\n\n  if (typeof offset === 'function') {\n    cb = offset\n    offset = 0\n    size = buf.length\n  } else if (typeof size === 'function') {\n    cb = size\n    size = buf.length - offset\n  } else if (typeof cb !== 'function') {\n    throw new TypeError('\"cb\" argument must be a function')\n  }\n  assertOffset(offset, buf.length)\n  assertSize(size, offset, buf.length)\n  return actualFill(buf, offset, size, cb)\n}\n\nfunction actualFill (buf, offset, size, cb) {\n  if (process.browser) {\n    var ourBuf = buf.buffer\n    var uint = new Uint8Array(ourBuf, offset, size)\n    crypto.getRandomValues(uint)\n    if (cb) {\n      process.nextTick(function () {\n        cb(null, buf)\n      })\n      return\n    }\n    return buf\n  }\n  if (cb) {\n    randombytes(size, function (err, bytes) {\n      if (err) {\n        return cb(err)\n      }\n      bytes.copy(buf, offset)\n      cb(null, buf)\n    })\n    return\n  }\n  var bytes = randombytes(size)\n  bytes.copy(buf, offset)\n  return buf\n}\nfunction randomFillSync (buf, offset, size) {\n  if (typeof offset === 'undefined') {\n    offset = 0\n  }\n  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n    throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n  }\n\n  assertOffset(offset, buf.length)\n\n  if (size === undefined) size = buf.length - offset\n\n  assertSize(size, offset, buf.length)\n\n  return actualFill(buf, offset, size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration. If the Promise is rejected, however, the\n          // result for this iteration will be rejected with the same\n          // reason. Note that rejections of yielded Promises are not\n          // thrown back into the generator function, as is the case\n          // when an awaited Promise is rejected. This difference in\n          // behavior between yield and await is important, because it\n          // allows the consumer to decide what to do with the yielded\n          // rejection (swallow it and continue, manually .throw it back\n          // into the generator, abandon iteration, whatever). With\n          // await, by contrast, there is no opportunity to examine the\n          // rejection reason outside the generator function, so the\n          // only option is to throw it from the await expression, and\n          // let the generator function handle the exception.\n          result.value = unwrapped;\n          resolve(result);\n        }, reject);\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (delegate.iterator.return) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // In sloppy mode, unbound `this` refers to the global object, fallback to\n  // Function constructor if we're in global strict mode. That is sadly a form\n  // of indirect eval which violates Content Security Policy.\n  (function() { return this })() || Function(\"return this\")()\n);\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\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);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', 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) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\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\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || 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);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\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;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\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.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\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    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\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', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\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  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\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.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\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 () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","'use strict'\nvar Buffer = require('buffer').Buffer\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n  var words = ARRAY16\n  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n  var al = this._a | 0\n  var bl = this._b | 0\n  var cl = this._c | 0\n  var dl = this._d | 0\n  var el = this._e | 0\n\n  var ar = this._a | 0\n  var br = this._b | 0\n  var cr = this._c | 0\n  var dr = this._d | 0\n  var er = this._e | 0\n\n  // computation\n  for (var i = 0; i < 80; i += 1) {\n    var tl\n    var tr\n    if (i < 16) {\n      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n    } else if (i < 32) {\n      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n    } else if (i < 48) {\n      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n    } else if (i < 64) {\n      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n    } else { // if (i<80) {\n      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n    }\n\n    al = el\n    el = dl\n    dl = rotl(cl, 10)\n    cl = bl\n    bl = tl\n\n    ar = er\n    er = dr\n    dr = rotl(cr, 10)\n    cr = br\n    br = tr\n  }\n\n  // update state\n  var t = (this._b + cl + dr) | 0\n  this._b = (this._c + dl + er) | 0\n  this._c = (this._d + el + ar) | 0\n  this._d = (this._e + al + br) | 0\n  this._e = (this._a + bl + cr) | 0\n  this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  buffer.writeInt32LE(this._e, 16)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\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","module.exports = require('./readable').PassThrough\n","module.exports = require('./readable').Transform\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\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\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) 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\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !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 TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\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 () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\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 (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    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', 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    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\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\n  onwriteStateUpdate(state);\n\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);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\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}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\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\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\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 Error('_write() is not implemented'));\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);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.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  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\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  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\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');\n"],"sourceRoot":""}