https://ethjs.github.io/offline/

298<script> /* eslint-disable */ 
299(function webpackUniversalModuleDefinition(root, factory) {
300	if(typeof exports === 'object' && typeof module === 'object')
301		module.exports = factory();
302	else if(typeof define === 'function' && define.amd)
303		define("ethAbi", [], factory);
304	else if(typeof exports === 'object')
305		exports["ethAbi"] = factory();
306	else
307		root["ethAbi"] = factory();
308})(this, function() {
309return /******/ (function(modules) { // webpackBootstrap
310/******/ 	// The module cache
311/******/ 	var installedModules = {};
312
313/******/ 	// The require function
314/******/ 	function __webpack_require__(moduleId) {
315
316/******/ 		// Check if module is in cache
317/******/ 		if(installedModules[moduleId])
318/******/ 			return installedModules[moduleId].exports;
319
320/******/ 		// Create a new module (and put it into the cache)
321/******/ 		var module = installedModules[moduleId] = {
322/******/ 			i: moduleId,
323/******/ 			l: false,
324/******/ 			exports: {}
325/******/ 		};
326
327/******/ 		// Execute the module function
328/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
329
330/******/ 		// Flag the module as loaded
331/******/ 		module.l = true;
332
333/******/ 		// Return the exports of the module
334/******/ 		return module.exports;
335/******/ 	}
336
337
338/******/ 	// expose the modules object (__webpack_modules__)
339/******/ 	__webpack_require__.m = modules;
340
341/******/ 	// expose the module cache
342/******/ 	__webpack_require__.c = installedModules;
343
344/******/ 	// identity function for calling harmory imports with the correct context
345/******/ 	__webpack_require__.i = function(value) { return value; };
346
347/******/ 	// define getter function for harmory exports
348/******/ 	__webpack_require__.d = function(exports, name, getter) {
349/******/ 		Object.defineProperty(exports, name, {
350/******/ 			configurable: false,
351/******/ 			enumerable: true,
352/******/ 			get: getter
353/******/ 		});
354/******/ 	};
355
356/******/ 	// Object.prototype.hasOwnProperty.call
357/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
358
359/******/ 	// __webpack_public_path__
360/******/ 	__webpack_require__.p = "";
361
362/******/ 	// Load entry module and return exports
363/******/ 	return __webpack_require__(__webpack_require__.s = 4);
364/******/ })
365/************************************************************************/
366/******/ ([
367/* 0 */
368/***/ function(module, exports, __webpack_require__) {
369
370"use strict";
371/* WEBPACK VAR INJECTION */(function(Buffer, global) {/*!
372 * The buffer module from node.js, for the browser.
373 *
374 * @author   Feross Aboukhadijeh <[email protected]> <http://feross.org>
375 * @license  MIT
376 */
377/* eslint-disable no-proto */
378
379'use strict'
380
381var base64 = __webpack_require__(5)
382var ieee754 = __webpack_require__(6)
383var isArray = __webpack_require__(8

383)
384
385exports.Buffer = Buffer
386exports.SlowBuffer = SlowBuffer
387exports.INSPECT_MAX_BYTES = 50
388
389/**
390 * If `Buffer.TYPED_ARRAY_SUPPORT`:
391 *   === true    Use Uint8Array implementation (fastest)
392 *   === false   Use Object implementation (most compatible, even IE6)
393 *
394 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
395 * Opera 11.6+, iOS 4.2+.
396 *
397 * Due to various browser bugs, sometimes the Object implementation will be used even
398 * when the browser supports typed arrays.
399 *
400 * Note:
401 *
402 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
403 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
404 *
405 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
406 *
407 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
408 *     incorrect length in some situations.
409
410 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
411 * get the Object implementation, which is slower but behaves correctly.
412 */
413Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
414  ? global.TYPED_ARRAY_SUPPORT
415  : typedArraySupport()
416
417/*
418 * Export kMaxLength after typed array support is determined.
419 */
420exports.kMaxLength = kMaxLength()
421
422function typedArraySupport () {
423  try {
424    var arr = new Uint8Array(1)
425    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
426    return arr.foo() === 42 && // typed array instances can be augmented
427        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
428        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
429  } catch (e) {
430    return false
431  }
432}
433
434function kMaxLength () {
435  return Buffer.TYPED_ARRAY_SUPPORT
436    ? 0x7fffffff
437    : 0x3fffffff
438}
439
440function createBuffer (that, length) {
441  if (kMaxLength() < length) {
442    throw new RangeError('Invalid typed array length')
443  }
444  if (Buffer.TYPED_ARRAY_SUPPORT) {
445    // Return an augmented `Uint8Array` instance, for best performance
446    that = new Uint8Array(length)
447    that.__proto__ = Buffer.prototype
448  } else {
449    // Fallback: Return an object instance of the Buffer class
450    if (that === null) {
451      that = new Buffer(length)
452    }
453    that.length = length
454  }
455
456  return that
457}
458
459/**
460 * The Buffer constructor returns instances of `Uint8Array` that have their
461 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
462 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
463 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
464 * returns a single octet.
465 *
466 * The `Uint8Array` prototype remains unmodified.
467 */
468
469function Buffer (arg, encodingOrOffset, length) {
470  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
471    return new Buffer(arg, encodingOrOffset, length)
472  }
473
474  // Common case.
475  if (typeof arg === 'number') {
476    if (typeof encodingOrOffset === 'string') {
477      throw new Error(
478        'If encoding is specified then the first argument must be a string'
479      )
480    }
481    return allocUnsafe(this, arg)
482  }
483  return from(this, arg, encodingOrOffset, length)
484}
485
486Buffer.poolSize = 8192 // not used by this implementation
487
488// TODO: Legacy, not needed anymore. Remove in next major version.
489Buffer._augment = function (arr) {
490  arr.__proto__ = Buffer.prototype
491  return arr
492}
493
494function from (that, value, encodingOrOffset, length) {
495  if (typeof value === 'number') {
496    throw new TypeError('"value" argument must not be a number')
497  }
498
499  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
500    return fromArrayBuffer(that, value, encodingOrOffset, length)
501  }
502
503  if (typeof value === 'string') {
504    return fromString(that, value, encodingOrOffset)
505  }
506
507  return fromObject(that, value)
508}
509
510/**
511 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
512 * if value is a number.
513 * Buffer.from(str[, encoding])
514 * Buffer.from(array)
515 * Buffer.from(buffer)
516 * Buffer.from(arrayBuffer[, byteOffset[, length]])
517 **/
518Buffer.from = function (value, encodingOrOffset, length) {
519  return from(null, value, encodingOrOffset, length)
520}
521
522if (Buffer.TYPED_ARRAY_SUPPORT) {
523  Buffer.prototype.__proto__ = Uint8Array.prototype
524  Buffer.__proto__ = Uint8Array
525  if (typeof Symbol !== 'undefined' && Symbol.species &&
526      Buffer[Symbol.species] === Buffer) {
527    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
528    Object.defineProperty(Buffer, Symbol.species, {
529      value: null,
530      configurable: true
531    })
532  }
533}
534
535function assertSize (size) {
536  if (typeof size !== 'number') {
537    throw new TypeError('"size" argument must be a number')
538  } else if (size < 0) {
539    throw new RangeError('"size" argument must not be negative')
540  }
541}
542
543function alloc (that, size, fill, encoding) {
544  assertSize(size)
545  if (size <= 0) {
546    return createBuffer(that, size)
547  }
548  if (fill !== undefined) {
549    // Only pay attention to encoding if it's a string. This
550    // prevents accidentally sending in a number that would
551    // be interpretted as a start offset.
552    return typeof encoding === 'string'
553      ? createBuffer(that, size).fill(fill, encoding)
554      : createBuffer(that, size).fill(fill)
555  }
556  return createBuffer(that, size)
557}
558
559/**
560 * Creates a new filled Buffer instance.
561 * alloc(size[, fill[, encoding]])
562 **/
563Buffer.alloc = function (size, fill, encoding) {
564  return alloc(null, size, fill, encoding)
565}
566
567function allocUnsafe (that, size) {
568  assertSize(size)
569  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
570  if (!Buffer.TYPED_ARRAY_SUPPORT) {
571    for (var i = 0; i < size; ++i) {
572      that[i] = 0
573    }
574  }
575  return that
576}
577
578/**
579 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
580 * */
581Buffer.allocUnsafe = function (size) {
582  return allocUnsafe(null, size)
583}
584/**
585 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
586 */
587Buffer.allocUnsafeSlow = function (size) {
588  return allocUnsafe(null, size)
589}
590
591function fromString (that, string, encoding) {
592  if (typeof encoding !== 'string' || encoding === '') {
593    encoding = 'utf8'
594  }
595
596  if (!Buffer.isEncoding(encoding)) {
597    throw new TypeError('"encoding" must be a valid string encoding')
598  }
599
600  var length = byteLength(string, encoding) | 0
601  that = createBuffer(that, length)
602
603  var actual = that.write(string, encoding)
604
605  if (actual !== length) {
606    // Writing a hex string, for example, that contains invalid characters will
607    // cause everything after the first invalid character to be ignored. (e.g.
608    // 'abxxcd' will be treated as 'ab')
609    that = that.slice(0, actual)
610  }
611
612  return that
613}
614
615function fromArrayLike (that, array) {
616  var length = array.length < 0 ? 0 : checked(array.length) | 0
617  that = createBuffer(that, length)
618  for (var i = 0; i < length; i += 1) {
619    that[i] = array[i] & 255
620  }
621  return that
622}
623
624function fromArrayBuffer (that, array, byteOffset, length) {
625  array.byteLength // this throws if `array` is not a valid ArrayBuffer
626
627  if (byteOffset < 0 || array.byteLength < byteOffset) {
628    throw new RangeError('\'offset\' is out of bounds')
629  }
630
631  if (array.byteLength < byteOffset + (length || 0)) {
632    throw new RangeError('\'length\' is out of bounds')
633  }
634
635  if (byteOffset === undefined && length === undefined) {
636    array = new Uint8Array(array)
637  } else if (length === undefined) {
638    array = new Uint8Array(array, byteOffset)
639  } else {
640    array = new Uint8Array(array, byteOffset, length)
641  }
642
643  if (Buffer.TYPED_ARRAY_SUPPORT) {
644    // Return an augmented `Uint8Array` instance, for best performance
645    that = array
646    that.__proto__ = Buffer.prototype
647  } else {
648    // Fallback: Return an object instance of the Buffer class
649    that = fromArrayLike(that, array)
650  }
651  return that
652}
653
654function fromObject (that, obj) {
655  if (Buffer.isBuffer(obj)) {
656    var len = checked(obj.length) | 0
657    that = createBuffer(that, len)
658
659    if (that.length === 0) {
660      return that
661    }
662
663    obj.copy(that, 0, 0, len)
664    return that
665  }
666
667  if (obj) {
668    if ((typeof ArrayBuffer !== 'undefined' &&
669        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
670      if (typeof obj.length !== 'number' || isnan(obj.length)) {
671        return createBuffer(that, 0)
672      }
673      return fromArrayLike(that, obj)
674    }
675
676    if (obj.type === 'Buffer' && isArray(obj.data)) {
677      return fromArrayLike(that, obj.data)
678    }
679  }
680
681  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
682}
683
684function checked (length) {
685  // Note: cannot use `length < kMaxLength()` here because that fails when
686  // length is NaN (which is otherwise coerced to zero.)
687  if (length >= kMaxLength()) {
688    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
689                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
690  }
691  return length | 0
692}
693
694function SlowBuffer (length) {
695  if (+length != length) { // eslint-disable-line eqeqeq
696    length = 0
697  }
698  return Buffer.alloc(+length)
699}
700
701Buffer.isBuffer = function isBuffer (b) {
702  return !!(b != null && b._isBuffer)
703}
704
705Buffer.compare = function compare (a, b) {
706  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
707    throw new TypeError('Arguments must be Buffers')
708  }
709
710  if (a === b) return 0
711
712  var x = a.length
713  var y = b.length
714
715  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
716    if (a[i] !== b[i]) {
717      x = a[i]
718      y = b[i]
719      break
720    }
721  }
722
723  if (x < y) return -1
724  if (y < x) return 1
725  return 0
726}
727
728Buffer.isEncoding = function isEncoding (encoding) {
729  switch (String(encoding).toLowerCase()) {
730    case 'hex':
731    case 'utf8':
732    case 'utf-8':
733    case 'ascii':
734    case 'latin1':
735    case 'binary':
736    case 'base64':
737    case 'ucs2':
738    case 'ucs-2':
739    case 'utf16le':
740    case 'utf-16le':
741      return true
742    default:
743      return false
744  }
745}
746
747Buffer.concat = function concat (list, length) {
748  if (!isArray(list)) {
749    throw new TypeError('"list" argument must be an Array of Buffers')
750  }
751
752  if (list.length === 0) {
753    return Buffer.alloc(0)
754  }
755
756  var i
757  if (length === undefined) {
758    length = 0
759    for (i = 0; i < list.length; ++i) {
760      length += list[i].length
761    }
762  }
763
764  var buffer = Buffer.allocUnsafe(length)
765  var pos = 0
766  for (i = 0; i < list.length; ++i) {
767    var buf = list[i]
768    if (!Buffer.isBuffer(buf)) {
769      throw new TypeError('"list" argument must be an Array of Buffers')
770    }
771    buf.copy(buffer, pos)
772    pos += buf.length
773  }
774  return buffer
775}
776
777function byteLength (string, encoding) {
778  if (Buffer.isBuffer(string)) {
779    return string.length
780  }
781  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
782      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
783    return string.byteLength
784  }
785  if (typeof string !== 'string') {
786    string = '' + string
787  }
788
789  var len = string.length
790  if (len === 0) return 0
791
792  // Use a for loop to avoid recursion
793  var loweredCase = false
794  for (;;) {
795    switch (encoding) {
796      case 'ascii':
797      case 'latin1':
798      case 'binary':
799        return len
800      case 'utf8':
801      case 'utf-8':
802      case undefined:
803        return utf8ToBytes(string).length
804      case 'ucs2':
805      case 'ucs-2':
806      case 'utf16le':
807      case 'utf-16le':
808        return len * 2
809      case 'hex':
810        return len >>> 1
811      case 'base64':
812        return base64ToBytes(string).length
813      default:
814        if (loweredCase) return utf8ToBytes(string).length // assume utf8
815        encoding = ('' + encoding).toLowerCase()
816        loweredCase = true
817    }
818  }
819}
820Buffer.byteLength = byteLength
821
822function slowToString (encoding, start, end) {
823  var loweredCase = false
824
825  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
826  // property of a typed array.
827
828  // This behaves neither like String nor Uint8Array in that we set start/end
829  // to their upper/lower bounds if the value passed is out of range.
830  // undefined is handled specially as per ECMA-262 6th Edition,
831  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
832  if (start === undefined || start < 0) {
833    start = 0
834  }
835  // Return early if start > this.length. Done here to prevent potential uint32
836  // coercion fail below.
837  if (start > this.length) {
838    return ''
839  }
840
841  if (end === undefined || end > this.length) {
842    end = this.length
843  }
844
845  if (end <= 0) {
846    return ''
847  }
848
849  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
850  end >>>= 0
851  start >>>= 0
852
853  if (end <= start) {
854    return ''
855  }
856
857  if (!encoding) encoding = 'utf8'
858
859  while (true) {
860    switch (encoding) {
861      case 'hex':
862        return hexSlice(this, start, end)
863
864      case 'utf8':
865      case 'utf-8':
866        return utf8Slice(this, start, end)
867
868      case 'ascii':
869        return asciiSlice(this, start, end)
870
871      case 'latin1':
872      case 'binary':
873        return latin1Slice(this, start, end)
874
875      case 'base64':
876        return base64Slice(this, start, end)
877
878      case 'ucs2':
879      case 'ucs-2':
880      case 'utf16le':
881      case 'utf-16le':
882        return utf16leSlice(this, start, end)
883
884      default:
885        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
886        encoding = (encoding + '').toLowerCase()
887        loweredCase = true
888    }
889  }
890}
891
892// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
893// Buffer instances.
894Buffer.prototype._isBuffer = true
895
896function swap (b, n, m) {
897  var i = b[n]
898  b[n] = b[m]
899  b[m] = i
900}
901
902Buffer.prototype.swap16 = function swap16 () {
903  var len = this.length
904  if (len % 2 !== 0) {
905    throw new RangeError('Buffer size must be a multiple of 16-bits')
906  }
907  for (var i = 0; i < len; i += 2) {
908    swap(this, i, i + 1)
909  }
910  return this
911}
912
913Buffer.prototype.swap32 = function swap32 () {
914  var len = this.length
915  if (len % 4 !== 0) {
916    throw new RangeError('Buffer size must be a multiple of 32-bits')
917  }
918  for (var i = 0; i < len; i += 4) {
919    swap(this, i, i + 3)
920    swap(this, i + 1, i + 2)
921  }
922  return this
923}
924
925Buffer.prototype.swap64 = function swap64 () {
926  var len = this.length
927  if (len % 8 !== 0) {
928    throw new RangeError('Buffer size must be a multiple of 64-bits')
929  }
930  for (var i = 0; i < len; i += 8) {
931    swap(this, i, i + 7)
932    swap(this, i + 1, i + 6)
933    swap(this, i + 2, i + 5)
934    swap(this, i + 3, i + 4)
935  }
936  return this
937}
938
939Buffer.prototype.toString = function toString () {
940  var length = this.length | 0
941  if (length === 0) return ''
942  if (arguments.length === 0) return utf8Slice(this, 0, length)
943  return slowToString.apply(this, arguments)
944}
945
946Buffer.prototype.equals = function equals (b) {
947  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
948  if (this === b) return true
949  return Buffer.compare(this, b) === 0
950}
951
952Buffer.prototype.inspect = function inspect () {
953  var str = ''
954  var max = exports.INSPECT_MAX_BYTES
955  if (this.length > 0) {
956    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
957    if (this.length > max) str += ' ... '
958  }
959  return '<Buffer ' + str + '>'
960}
961
962Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
963  if (!Buffer.isBuffer(target)) {
964    throw new TypeError('Argument must be a Buffer')
965  }
966
967  if (start === undefined) {
968    start = 0
969  }
970  if (end === undefined) {
971    end = target ? target.length : 0
972  }
973  if (thisStart === undefined) {
974    thisStart = 0
975  }
976  if (thisEnd === undefined) {
977    thisEnd = this.length
978  }
979
980  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
981    throw new RangeError('out of range index')
982  }
983
984  if (thisStart >= thisEnd && start >= end) {
985    return 0
986  }
987  if (thisStart >= thisEnd) {
988    return -1
989  }
990  if (start >= end) {
991    return 1
992  }
993
994  start >>>= 0
995  end >>>= 0
996  thisStart >>>= 0
997  thisEnd >>>= 0
998
999  if (this === target) return 0
1000
1001  var x = thisEnd - thisStart
1002  var y = end - start
1003  var len = Math.min(x, y)
1004
1005  var thisCopy = this.slice(thisStart, thisEnd)
1006  var targetCopy = target.slice(start, end)
1007
1008  for (var i = 0; i < len; ++i) {
1009    if (thisCopy[i] !== targetCopy[i]) {
1010      x = thisCopy[i]
1011      y = targetCopy[i]
1012      break
1013    }
1014  }
1015
1016  if (x < y) return -1
1017  if (y < x) return 1
1018  return 0
1019}
1020
1021// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
1022// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
1023//
1024// Arguments:
1025// - buffer - a Buffer to search
1026// - val - a string, Buffer, or number
1027// - byteOffset - an index into `buffer`; will be clamped to an int32
1028// - encoding - an optional encoding, relevant is val is a string
1029// - dir - true for indexOf, false for lastIndexOf
1030function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
1031  // Empty buffer means no match
1032  if (buffer.length === 0) return -1
1033
1034  // Normalize byteOffset
1035  if (typeof byteOffset === 'string') {
1036    encoding = byteOffset
1037    byteOffset = 0
1038  } else if (byteOffset > 0x7fffffff) {
1039    byteOffset = 0x7fffffff
1040  } else if (byteOffset < -0x80000000) {
1041    byteOffset = -0x80000000
1042  }
1043  byteOffset = +byteOffset  // Coerce to Number.
1044  if (isNaN(byteOffset)) {
1045    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
1046    byteOffset = dir ? 0 : (buffer.length - 1)
1047  }
1048
1049  // Normalize byteOffset: negative offsets start from the end of the buffer
1050  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
1051  if (byteOffset >= buffer.length) {
1052    if (dir) return -1
1053    else byteOffset = buffer.length - 1
1054  } else if (byteOffset < 0) {
1055    if (dir) byteOffset = 0
1056    else return -1
1057  }
1058
1059  // Normalize val
1060  if (typeof val === 'string') {
1061    val = Buffer.from(val, encoding)
1062  }
1063
1064  // Finally, search either indexOf (if dir is true) or lastIndexOf
1065  if (Buffer.isBuffer(val)) {
1066    // Special case: looking for empty string/buffer always fails
1067    if (val.length === 0) {
1068      return -1
1069    }
1070    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
1071  } else if (typeof val === 'number') {
1072    val = val & 0xFF // Search for a byte value [0-255]
1073    if (Buffer.TYPED_ARRAY_SUPPORT &&
1074        typeof Uint8Array.prototype.indexOf === 'function') {
1075      if (dir) {
1076        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
1077      } else {
1078        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
1079      }
1080    }
1081    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
1082  }
1083
1084  throw new TypeError('val must be string, number or Buffer')
1085}
1086
1087function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
1088  var indexSize = 1
1089  var arrLength = arr.length
1090  var valLength = val.length
1091
1092  if (encoding !== undefined) {
1093    encoding = String(encoding).toLowerCase()
1094    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
1095        encoding === 'utf16le' || encoding === 'utf-16le') {
1096      if (arr.length < 2 || val.length < 2) {
1097        return -1
1098      }
1099      indexSize = 2
1100      arrLength /= 2
1101      valLength /= 2
1102      byteOffset /= 2
1103    }
1104  }
1105
1106  function read (buf, i) {
1107    if (indexSize === 1) {
1108      return buf[i]
1109    } else {
1110      return buf.readUInt16BE(i * indexSize)
1111    }
1112  }
1113
1114  var i
1115  if (dir) {
1116    var foundIndex = -1
1117    for (i = byteOffset; i < arrLength; i++) {
1118      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
1119        if (foundIndex === -1) foundIndex = i
1120        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
1121      } else {
1122        if (foundIndex !== -1) i -= i - foundIndex
1123        foundIndex = -1
1124      }
1125    }
1126  } else {
1127    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
1128    for (i = byteOffset; i >= 0; i--) {
1129      var found = true
1130      for (var j = 0; j < valLength; j++) {
1131        if (read(arr, i + j) !== read(val, j)) {
1132          found = false
1133          break
1134        }
1135      }
1136      if (found) return i
1137    }
1138  }
1139
1140  return -1
1141}
1142
1143Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
1144  return this.indexOf(val, byteOffset, encoding) !== -1
1145}
1146
1147Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
1148  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
1149}
1150
1151Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
1152  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
1153}
1154
1155function hexWrite (buf, string, offset, length) {
1156  offset = Number(offset) || 0
1157  var remaining = buf.length - offset
1158  if (!length) {
1159    length = remaining
1160  } else {
1161    length = Number(length)
1162    if (length > remaining) {
1163      length = remaining
1164    }
1165  }
1166
1167  // must be an even number of digits
1168  var strLen = string.length
1169  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
1170
1171  if (length > strLen / 2) {
1172    length = strLen / 2
1173  }
1174  for (var i = 0; i < length; ++i) {
1175    var parsed = parseInt(string.substr(i * 2, 2), 16)
1176    if (isNaN(parsed)) return i
1177    buf[offset + i] = parsed
1178  }
1179  return i
1180}
1181
1182function utf8Write (buf, string, offset, length) {
1183  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
1184}
1185
1186function asciiWrite (buf, string, offset, length) {
1187  return blitBuffer(asciiToBytes(string), buf, offset, length)
1188}
1189
1190function latin1Write (buf, string, offset, length) {
1191  return asciiWrite(buf, string, offset, length)
1192}
1193
1194function base64Write (buf, string, offset, length) {
1195  return blitBuffer(base64ToBytes(string), buf, offset, length)
1196}
1197
1198function ucs2Write (buf, string, offset, length) {
1199  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
1200}
1201
1202Buffer.prototype.write = function write (string, offset, length, encoding) {
1203  // Buffer#write(string)
1204  if (offset === undefined) {
1205    encoding = 'utf8'
1206    length = this.length
1207    offset = 0
1208  // Buffer#write(string, encoding)
1209  } else if (length === undefined && typeof offset === 'string') {
1210    encoding = offset
1211    length = this.length
1212    offset = 0
1213  // Buffer#write(string, offset[, length][, encoding])
1214  } else if (isFinite(offset)) {
1215    offset = offset | 0
1216    if (isFinite(length)) {
1217      length = length | 0
1218      if (encoding === undefined) encoding = 'utf8'
1219    } else {
1220      encoding = length
1221      length = undefined
1222    }
1223  // legacy write(string, encoding, offset, length) - remove in v0.13
1224  } else {
1225    throw new Error(
1226      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
1227    )
1228  }
1229
1230  var remaining = this.length - offset
1231  if (length === undefined || length > remaining) length = remaining
1232
1233  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
1234    throw new RangeError('Attempt to write outside buffer bounds')
1235  }
1236
1237  if (!encoding) encoding = 'utf8'
1238
1239  var loweredCase = false
1240  for (;;) {
1241    switch (encoding) {
1242      case 'hex':
1243        return hexWrite(this, string, offset, length)
1244
1245      case 'utf8':
1246      case 'utf-8':
1247        return utf8Write(this, string, offset, length)
1248
1249      case 'ascii':
1250        return asciiWrite(this, string, offset, length)
1251
1252      case 'latin1':
1253      case 'binary':
1254        return latin1Write(this, string, offset, length)
1255
1256      case 'base64':
1257        // Warning: maxLength not taken into account in base64Write
1258        return base64Write(this, string, offset, length)
1259
1260      case 'ucs2':
1261      case 'ucs-2':
1262      case 'utf16le':
1263      case 'utf-16le':
1264        return ucs2Write(this, string, offset, length)
1265
1266      default:
1267        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
1268        encoding = ('' + encoding).toLowerCase()
1269        loweredCase = true
1270    }
1271  }
1272}
1273
1274Buffer.prototype.toJSON = function toJSON () {
1275  return {
1276    type: 'Buffer',
1277    data: Array.prototype.slice.call(this._arr || this, 0)
1278  }
1279}
1280
1281function base64Slice (buf, start, end) {
1282  if (start === 0 && end === buf.length) {
1283    return base64.fromByteArray(buf)
1284  } else {
1285    return base64.fromByteArray(buf.slice(start, end))
1286  }
1287}
1288
1289function utf8Slice (buf, start, end) {
1290  end = Math.min(buf.length, end)
1291  var res = []
1292
1293  var i = start
1294  while (i < end) {
1295    var firstByte = buf[i]
1296    var codePoint = null
1297    var bytesPerSequence = (firstByte > 0xEF) ? 4
1298      : (firstByte > 0xDF) ? 3
1299      : (firstByte > 0xBF) ? 2
1300      : 1
1301
1302    if (i + bytesPerSequence <= end) {
1303      var secondByte, thirdByte, fourthByte, tempCodePoint
1304
1305      switch (bytesPerSequence) {
1306        case 1:
1307          if (firstByte < 0x80) {
1308            codePoint = firstByte
1309          }
1310          break
1311        case 2:
1312          secondByte = buf[i + 1]
1313          if ((secondByte & 0xC0) === 0x80) {
1314            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
1315            if (tempCodePoint > 0x7F) {
1316              codePoint = tempCodePoint
1317            }
1318          }
1319          break
1320        case 3:
1321          secondByte = buf[i + 1]
1322          thirdByte = buf[i + 2]
1323          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
1324            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
1325            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
1326              codePoint = tempCodePoint
1327            }
1328          }
1329          break
1330        case 4:
1331          secondByte = buf[i + 1]
1332          thirdByte = buf[i + 2]
1333          fourthByte = buf[i + 3]
1334          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
1335            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
1336            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
1337              codePoint = tempCodePoint
1338            }
1339          }
1340      }
1341    }
1342
1343    if (codePoint === null) {
1344      // we did not generate a valid codePoint so insert a
1345      // replacement char (U+FFFD) and advance only 1 byte
1346      codePoint = 0xFFFD
1347      bytesPerSequence = 1
1348    } else if (codePoint > 0xFFFF) {
1349      // encode to utf16 (surrogate pair dance)
1350      codePoint -= 0x10000
1351      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
1352      codePoint = 0xDC00 | codePoint & 0x3FF
1353    }
1354
1355    res.push(codePoint)
1356    i += bytesPerSequence
1357  }
1358
1359  return decodeCodePointsArray(res)
1360}
1361
1362// Based on http://stackoverflow.com/a/22747272/680742, the browser with
1363// the lowest limit is Chrome, with 0x10000 args.
1364// We go 1 magnitude less, for safety
1365var MAX_ARGUMENTS_LENGTH = 0x1000
1366
1367function decodeCodePointsArray (codePoints) {
1368  var len = codePoints.length
1369  if (len <= MAX_ARGUMENTS_LENGTH) {
1370    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
1371  }
1372
1373  // Decode in chunks to avoid "call stack size exceeded".
1374  var res = ''
1375  var i = 0
1376  while (i < len) {
1377    res += String.fromCharCode.apply(
1378      String,
1379      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
1380    )
1381  }
1382  return res
1383}
1384
1385function asciiSlice (buf, start, end) {
1386  var ret = ''
1387  end = Math.min(buf.length, end)
1388
1389  for (var i = start; i < end; ++i) {
1390    ret += String.fromCharCode(buf[i] & 0x7F)
1391  }
1392  return ret
1393}
1394
1395function latin1Slice (buf, start, end) {
1396  var ret = ''
1397  end = Math.min(buf.length, end)
1398
1399  for (var i = start; i < end; ++i) {
1400    ret += String.fromCharCode(buf[i])
1401  }
1402  return ret
1403}
1404
1405function hexSlice (buf, start, end) {
1406  var len = buf.length
1407
1408  if (!start || start < 0) start = 0
1409  if (!end || end < 0 || end > len) end = len
1410
1411  var out = ''
1412  for (var i = start; i < end; ++i) {
1413    out += toHex(buf[i])
1414  }
1415  return out
1416}
1417
1418function utf16leSlice (buf, start, end) {
1419  var bytes = buf.slice(start, end)
1420  var res = ''
1421  for (var i = 0; i < bytes.length; i += 2) {
1422    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
1423  }
1424  return res
1425}
1426
1427Buffer.prototype.slice = function slice (start, end) {
1428  var len = this.length
1429  start = ~~start
1430  end = end === undefined ? len : ~~end
1431
1432  if (start < 0) {
1433    start += len
1434    if (start < 0) start = 0
1435  } else if (start > len) {
1436    start = len
1437  }
1438
1439  if (end < 0) {
1440    end += len
1441    if (end < 0) end = 0
1442  } else if (end > len) {
1443    end = len
1444  }
1445
1446  if (end < start) end = start
1447
1448  var newBuf
1449  if (Buffer.TYPED_ARRAY_SUPPORT) {
1450    newBuf = this.subarray(start, end)
1451    newBuf.__proto__ = Buffer.prototype
1452  } else {
1453    var sliceLen = end - start
1454    newBuf = new Buffer(sliceLen, undefined)
1455    for (var i = 0; i < sliceLen; ++i) {
1456      newBuf[i] = this[i + start]
1457    }
1458  }
1459
1460  return newBuf
1461}
1462
1463/*
1464 * Need to make sure that buffer isn't trying to write out of bounds.
1465 */
1466function checkOffset (offset, ext, length) {
1467  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
1468  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
1469}
1470
1471Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
1472  offset = offset | 0
1473  byteLength = byteLength | 0
1474  if (!noAssert) checkOffset(offset, byteLength, this.length)
1475
1476  var val = this[offset]
1477  var mul = 1
1478  var i = 0
1479  while (++i < byteLength && (mul *= 0x100)) {
1480    val += this[offset + i] * mul
1481  }
1482
1483  return val
1484}
1485
1486Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
1487  offset = offset | 0
1488  byteLength = byteLength | 0
1489  if (!noAssert) {
1490    checkOffset(offset, byteLength, this.length)
1491  }
1492
1493  var val = this[offset + --byteLength]
1494  var mul = 1
1495  while (byteLength > 0 && (mul *= 0x100)) {
1496    val += this[offset + --byteLength] * mul
1497  }
1498
1499  return val
1500}
1501
1502Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
1503  if (!noAssert) checkOffset(offset, 1, this.length)
1504  return this[offset]
1505}
1506
1507Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
1508  if (!noAssert) checkOffset(offset, 2, this.length)
1509  return this[offset] | (this[offset + 1] << 8)
1510}
1511
1512Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
1513  if (!noAssert) checkOffset(offset, 2, this.length)
1514  return (this[offset] << 8) | this[offset + 1]
1515}
1516
1517Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
1518  if (!noAssert) checkOffset(offset, 4, this.length)
1519
1520  return ((this[offset]) |
1521      (this[offset + 1] << 8) |
1522      (this[offset + 2] << 16)) +
1523      (this[offset + 3] * 0x1000000)
1524}
1525
1526Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
1527  if (!noAssert) checkOffset(offset, 4, this.length)
1528
1529  return (this[offset] * 0x1000000) +
1530    ((this[offset + 1] << 16) |
1531    (this[offset + 2] << 8) |
1532    this[offset + 3])
1533}
1534
1535Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
1536  offset = offset | 0
1537  byteLength = byteLength | 0
1538  if (!noAssert) checkOffset(offset, byteLength, this.length)
1539
1540  var val = this[offset]
1541  var mul = 1
1542  var i = 0
1543  while (++i < byteLength && (mul *= 0x100)) {
1544    val += this[offset + i] * mul
1545  }
1546  mul *= 0x80
1547
1548  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1549
1550  return val
1551}
1552
1553Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
1554  offset = offset | 0
1555  byteLength = byteLength | 0
1556  if (!noAssert) checkOffset(offset, byteLength, this.length)
1557
1558  var i = byteLength
1559  var mul = 1
1560  var val = this[offset + --i]
1561  while (i > 0 && (mul *= 0x100)) {
1562    val += this[offset + --i] * mul
1563  }
1564  mul *= 0x80
1565
1566  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
1567
1568  return val
1569}
1570
1571Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
1572  if (!noAssert) checkOffset(offset, 1, this.length)
1573  if (!(this[offset] & 0x80)) return (this[offset])
1574  return ((0xff - this[offset] + 1) * -1)
1575}
1576
1577Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
1578  if (!noAssert) checkOffset(offset, 2, this.length)
1579  var val = this[offset] | (this[offset + 1] << 8)
1580  return (val & 0x8000) ? val | 0xFFFF0000 : val
1581}
1582
1583Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
1584  if (!noAssert) checkOffset(offset, 2, this.length)
1585  var val = this[offset + 1] | (this[offset] << 8)
1586  return (val & 0x8000) ? val | 0xFFFF0000 : val
1587}
1588
1589Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
1590  if (!noAssert) checkOffset(offset, 4, this.length)
1591
1592  return (this[offset]) |
1593    (this[offset + 1] << 8) |
1594    (this[offset + 2] << 16) |
1595    (this[offset + 3] << 24)
1596}
1597
1598Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
1599  if (!noAssert) checkOffset(offset, 4, this.length)
1600
1601  return (this[offset] << 24) |
1602    (this[offset + 1] << 16) |
1603    (this[offset + 2] << 8) |
1604    (this[offset + 3])
1605}
1606
1607Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
1608  if (!noAssert) checkOffset(offset, 4, this.length)
1609  return ieee754.read(this, offset, true, 23, 4)
1610}
1611
1612Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
1613  if (!noAssert) checkOffset(offset, 4, this.length)
1614  return ieee754.read(this, offset, false, 23, 4)
1615}
1616
1617Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
1618  if (!noAssert) checkOffset(offset, 8, this.length)
1619  return ieee754.read(this, offset, true, 52, 8)
1620}
1621
1622Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
1623  if (!noAssert) checkOffset(offset, 8, this.length)
1624  return ieee754.read(this, offset, false, 52, 8)
1625}
1626
1627function checkInt (buf, value, offset, ext, max, min) {
1628  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
1629  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
1630  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1631}
1632
1633Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
1634  value = +value
1635  offset = offset | 0
1636  byteLength = byteLength | 0
1637  if (!noAssert) {
1638    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1639    checkInt(this, value, offset, byteLength, maxBytes, 0)
1640  }
1641
1642  var mul = 1
1643  var i = 0
1644  this[offset] = value & 0xFF
1645  while (++i < byteLength && (mul *= 0x100)) {
1646    this[offset + i] = (value / mul) & 0xFF
1647  }
1648
1649  return offset + byteLength
1650}
1651
1652Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
1653  value = +value
1654  offset = offset | 0
1655  byteLength = byteLength | 0
1656  if (!noAssert) {
1657    var maxBytes = Math.pow(2, 8 * byteLength) - 1
1658    checkInt(this, value, offset, byteLength, maxBytes, 0)
1659  }
1660
1661  var i = byteLength - 1
1662  var mul = 1
1663  this[offset + i] = value & 0xFF
1664  while (--i >= 0 && (mul *= 0x100)) {
1665    this[offset + i] = (value / mul) & 0xFF
1666  }
1667
1668  return offset + byteLength
1669}
1670
1671Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
1672  value = +value
1673  offset = offset | 0
1674  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
1675  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1676  this[offset] = (value & 0xff)
1677  return offset + 1
1678}
1679
1680function objectWriteUInt16 (buf, value, offset, littleEndian) {
1681  if (value < 0) value = 0xffff + value + 1
1682  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
1683    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
1684      (littleEndian ? i : 1 - i) * 8
1685  }
1686}
1687
1688Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
1689  value = +value
1690  offset = offset | 0
1691  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1692  if (Buffer.TYPED_ARRAY_SUPPORT) {
1693    this[offset] = (value & 0xff)
1694    this[offset + 1] = (value >>> 8)
1695  } else {
1696    objectWriteUInt16(this, value, offset, true)
1697  }
1698  return offset + 2
1699}
1700
1701Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
1702  value = +value
1703  offset = offset | 0
1704  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
1705  if (Buffer.TYPED_ARRAY_SUPPORT) {
1706    this[offset] = (value >>> 8)
1707    this[offset + 1] = (value & 0xff)
1708  } else {
1709    objectWriteUInt16(this, value, offset, false)
1710  }
1711  return offset + 2
1712}
1713
1714function objectWriteUInt32 (buf, value, offset, littleEndian) {
1715  if (value < 0) value = 0xffffffff + value + 1
1716  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
1717    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
1718  }
1719}
1720
1721Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
1722  value = +value
1723  offset = offset | 0
1724  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1725  if (Buffer.TYPED_ARRAY_SUPPORT) {
1726    this[offset + 3] = (value >>> 24)
1727    this[offset + 2] = (value >>> 16)
1728    this[offset + 1] = (value >>> 8)
1729    this[offset] = (value & 0xff)
1730  } else {
1731    objectWriteUInt32(this, value, offset, true)
1732  }
1733  return offset + 4
1734}
1735
1736Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
1737  value = +value
1738  offset = offset | 0
1739  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
1740  if (Buffer.TYPED_ARRAY_SUPPORT) {
1741    this[offset] = (value >>> 24)
1742    this[offset + 1] = (value >>> 16)
1743    this[offset + 2] = (value >>> 8)
1744    this[offset + 3] = (value & 0xff)
1745  } else {
1746    objectWriteUInt32(this, value, offset, false)
1747  }
1748  return offset + 4
1749}
1750
1751Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
1752  value = +value
1753  offset = offset | 0
1754  if (!noAssert) {
1755    var limit = Math.pow(2, 8 * byteLength - 1)
1756
1757    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1758  }
1759
1760  var i = 0
1761  var mul = 1
1762  var sub = 0
1763  this[offset] = value & 0xFF
1764  while (++i < byteLength && (mul *= 0x100)) {
1765    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
1766      sub = 1
1767    }
1768    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1769  }
1770
1771  return offset + byteLength
1772}
1773
1774Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
1775  value = +value
1776  offset = offset | 0
1777  if (!noAssert) {
1778    var limit = Math.pow(2, 8 * byteLength - 1)
1779
1780    checkInt(this, value, offset, byteLength, limit - 1, -limit)
1781  }
1782
1783  var i = byteLength - 1
1784  var mul = 1
1785  var sub = 0
1786  this[offset + i] = value & 0xFF
1787  while (--i >= 0 && (mul *= 0x100)) {
1788    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
1789      sub = 1
1790    }
1791    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
1792  }
1793
1794  return offset + byteLength
1795}
1796
1797Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
1798  value = +value
1799  offset = offset | 0
1800  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
1801  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
1802  if (value < 0) value = 0xff + value + 1
1803  this[offset] = (value & 0xff)
1804  return offset + 1
1805}
1806
1807Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
1808  value = +value
1809  offset = offset | 0
1810  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1811  if (Buffer.TYPED_ARRAY_SUPPORT) {
1812    this[offset] = (value & 0xff)
1813    this[offset + 1] = (value >>> 8)
1814  } else {
1815    objectWriteUInt16(this, value, offset, true)
1816  }
1817  return offset + 2
1818}
1819
1820Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
1821  value = +value
1822  offset = offset | 0
1823  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
1824  if (Buffer.TYPED_ARRAY_SUPPORT) {
1825    this[offset] = (value >>> 8)
1826    this[offset + 1] = (value & 0xff)
1827  } else {
1828    objectWriteUInt16(this, value, offset, false)
1829  }
1830  return offset + 2
1831}
1832
1833Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
1834  value = +value
1835  offset = offset | 0
1836  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1837  if (Buffer.TYPED_ARRAY_SUPPORT) {
1838    this[offset] = (value & 0xff)
1839    this[offset + 1] = (value >>> 8)
1840    this[offset + 2] = (value >>> 16)
1841    this[offset + 3] = (value >>> 24)
1842  } else {
1843    objectWriteUInt32(this, value, offset, true)
1844  }
1845  return offset + 4
1846}
1847
1848Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
1849  value = +value
1850  offset = offset | 0
1851  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
1852  if (value < 0) value = 0xffffffff + value + 1
1853  if (Buffer.TYPED_ARRAY_SUPPORT) {
1854    this[offset] = (value >>> 24)
1855    this[offset + 1] = (value >>> 16)
1856    this[offset + 2] = (value >>> 8)
1857    this[offset + 3] = (value & 0xff)
1858  } else {
1859    objectWriteUInt32(this, value, offset, false)
1860  }
1861  return offset + 4
1862}
1863
1864function checkIEEE754 (buf, value, offset, ext, max, min) {
1865  if (offset + ext > buf.length) throw new RangeError('Index out of range')
1866  if (offset < 0) throw new RangeError('Index out of range')
1867}
1868
1869function writeFloat (buf, value, offset, littleEndian, noAssert) {
1870  if (!noAssert) {
1871    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
1872  }
1873  ieee754.write(buf, value, offset, littleEndian, 23, 4)
1874  return offset + 4
1875}
1876
1877Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
1878  return writeFloat(this, value, offset, true, noAssert)
1879}
1880
1881Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
1882  return writeFloat(this, value, offset, false, noAssert)
1883}
1884
1885function writeDouble (buf, value, offset, littleEndian, noAssert) {
1886  if (!noAssert) {
1887    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
1888  }
1889  ieee754.write(buf, value, offset, littleEndian, 52, 8)
1890  return offset + 8
1891}
1892
1893Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
1894  return writeDouble(this, value, offset, true, noAssert)
1895}
1896
1897Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
1898  return writeDouble(this, value, offset, false, noAssert)
1899}
1900
1901// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
1902Buffer.prototype.copy = function copy (target, targetStart, start, end) {
1903  if (!start) start = 0
1904  if (!end && end !== 0) end = this.length
1905  if (targetStart >= target.length) targetStart = target.length
1906  if (!targetStart) targetStart = 0
1907  if (end > 0 && end < start) end = start
1908
1909  // Copy 0 bytes; we're done
1910  if (end === start) return 0
1911  if (target.length === 0 || this.length === 0) return 0
1912
1913  // Fatal error conditions
1914  if (targetStart < 0) {
1915    throw new RangeError('targetStart out of bounds')
1916  }
1917  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
1918  if (end < 0) throw new RangeError('sourceEnd out of bounds')
1919
1920  // Are we oob?
1921  if (end > this.length) end = this.length
1922  if (target.length - targetStart < end - start) {
1923    end = target.length - targetStart + start
1924  }
1925
1926  var len = end - start
1927  var i
1928
1929  if (this === target && start < targetStart && targetStart < end) {
1930    // descending copy from end
1931    for (i = len - 1; i >= 0; --i) {
1932      target[i + targetStart] = this[i + start]
1933    }
1934  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
1935    // ascending copy from start
1936    for (i = 0; i < len; ++i) {
1937      target[i + targetStart] = this[i + start]
1938    }
1939  } else {
1940    Uint8Array.prototype.set.call(
1941      target,
1942      this.subarray(start, start + len),
1943      targetStart
1944    )
1945  }
1946
1947  return len
1948}
1949
1950// Usage:
1951//    buffer.fill(number[, offset[, end]])
1952//    buffer.fill(buffer[, offset[, end]])
1953//    buffer.fill(string[, offset[, end]][, encoding])
1954Buffer.prototype.fill = function fill (val, start, end, encoding) {
1955  // Handle string cases:
1956  if (typeof val === 'string') {
1957    if (typeof start === 'string') {
1958      encoding = start
1959      start = 0
1960      end = this.length
1961    } else if (typeof end === 'string') {
1962      encoding = end
1963      end = this.length
1964    }
1965    if (val.length === 1) {
1966      var code = val.charCodeAt(0)
1967      if (code < 256) {
1968        val = code
1969      }
1970    }
1971    if (encoding !== undefined && typeof encoding !== 'string') {
1972      throw new TypeError('encoding must be a string')
1973    }
1974    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
1975      throw new TypeError('Unknown encoding: ' + encoding)
1976    }
1977  } else if (typeof val === 'number') {
1978    val = val & 255
1979  }
1980
1981  // Invalid ranges are not set to a default, so can range check early.
1982  if (start < 0 || this.length < start || this.length < end) {
1983    throw new RangeError('Out of range index')
1984  }
1985
1986  if (end <= start) {
1987    return this
1988  }
1989
1990  start = start >>> 0
1991  end = end === undefined ? this.length : end >>> 0
1992
1993  if (!val) val = 0
1994
1995  var i
1996  if (typeof val === 'number') {
1997    for (i = start; i < end; ++i) {
1998      this[i] = val
1999    }
2000  } else {
2001    var bytes = Buffer.isBuffer(val)
2002      ? val
2003      : utf8ToBytes(new Buffer(val, encoding).toString())
2004    var len = bytes.length
2005    for (i = 0; i < end - start; ++i) {
2006      this[i + start] = bytes[i % len]
2007    }
2008  }
2009
2010  return this
2011}
2012
2013// HELPER FUNCTIONS
2014// ================
2015
2016var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
2017
2018function base64clean (str) {
2019  // Node strips out invalid characters like \n and \t from the string, base64-js does not
2020  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
2021  // Node converts strings with length < 2 to ''
2022  if (str.length < 2) return ''
2023  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
2024  while (str.length % 4 !== 0) {
2025    str = str + '='
2026  }
2027  return str
2028}
2029
2030function stringtrim (str) {
2031  if (str.trim) return str.trim()
2032  return str.replace(/^\s+|\s+$/g, '')
2033}
2034
2035function toHex (n) {
2036  if (n < 16) return '0' + n.toString(16)
2037  return n.toString(16)
2038}
2039
2040function utf8ToBytes (string, units) {
2041  units = units || Infinity
2042  var codePoint
2043  var length = string.length
2044  var leadSurrogate = null
2045  var bytes = []
2046
2047  for (var i = 0; i < length; ++i) {
2048    codePoint = string.charCodeAt(i)
2049
2050    // is surrogate component
2051    if (codePoint > 0xD7FF && codePoint < 0xE000) {
2052      // last char was a lead
2053      if (!leadSurrogate) {
2054        // no lead yet
2055        if (codePoint > 0xDBFF) {
2056          // unexpected trail
2057          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2058          continue
2059        } else if (i + 1 === length) {
2060          // unpaired lead
2061          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2062          continue
2063        }
2064
2065        // valid lead
2066        leadSurrogate = codePoint
2067
2068        continue
2069      }
2070
2071      // 2 leads in a row
2072      if (codePoint < 0xDC00) {
2073        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2074        leadSurrogate = codePoint
2075        continue
2076      }
2077
2078      // valid surrogate pair
2079      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
2080    } else if (leadSurrogate) {
2081      // valid bmp char, but last char was a lead
2082      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
2083    }
2084
2085    leadSurrogate = null
2086
2087    // encode utf8
2088    if (codePoint < 0x80) {
2089      if ((units -= 1) < 0) break
2090      bytes.push(codePoint)
2091    } else if (codePoint < 0x800) {
2092      if ((units -= 2) < 0) break
2093      bytes.push(
2094        codePoint >> 0x6 | 0xC0,
2095        codePoint & 0x3F | 0x80
2096      )
2097    } else if (codePoint < 0x10000) {
2098      if ((units -= 3) < 0) break
2099      bytes.push(
2100        codePoint >> 0xC | 0xE0,
2101        codePoint >> 0x6 & 0x3F | 0x80,
2102        codePoint & 0x3F | 0x80
2103      )
2104    } else if (codePoint < 0x110000) {
2105      if ((units -= 4) < 0) break
2106      bytes.push(
2107        codePoint >> 0x12 | 0xF0,
2108        codePoint >> 0xC & 0x3F | 0x80,
2109        codePoint >> 0x6 & 0x3F | 0x80,
2110        codePoint & 0x3F | 0x80
2111      )
2112    } else {
2113      throw new Error('Invalid code point')
2114    }
2115  }
2116
2117  return bytes
2118}
2119
2120function asciiToBytes (str) {
2121  var byteArray = []
2122  for (var i = 0; i < str.length; ++i) {
2123    // Node's code seems to be doing this and not & 0x7F..
2124    byteArray.push(str.charCodeAt(i) & 0xFF)
2125  }
2126  return byteArray
2127}
2128
2129function utf16leToBytes (str, units) {
2130  var c, hi, lo
2131  var byteArray = []
2132  for (var i = 0; i < str.length; ++i) {
2133    if ((units -= 2) < 0) break
2134
2135    c = str.charCodeAt(i)
2136    hi = c >> 8
2137    lo = c % 256
2138    byteArray.push(lo)
2139    byteArray.push(hi)
2140  }
2141
2142  return byteArray
2143}
2144
2145function base64ToBytes (str) {
2146  return base64.toByteArray(base64clean(str))
2147}
2148
2149function blitBuffer (src, dst, offset, length) {
2150  for (var i = 0; i < length; ++i) {
2151    if ((i + offset >= dst.length) || (i >= src.length)) break
2152    dst[i + offset] = src[i]
2153  }
2154  return i
2155}
2156
2157function isnan (val) {
2158  return val !== val // eslint-disable-line no-self-compare
2159}
2160
2161/* WEBPACK VAR INJECTION */}.call(

2161exports, __webpack_require__(0).Buffer, __webpack_require__(2)))
2162
2163/***/ },
2164/* 1 */
2165/***/ function(module, exports, __webpack_require__) {
2166
2167/* WEBPACK VAR INJECTION */(function(module) {(function (module, exports) {
2168  'use strict';
2169
2170  // Utils
2171  function assert (val, msg) {
2172    if (!val) throw new Error(msg || 'Assertion failed');
2173  }
2174
2175  // Could use `inherits` module, but don't want to move from single file
2176  // architecture yet.
2177  function inherits (ctor, superCtor) {
2178    ctor.super_ = superCtor;
2179    var TempCtor = function () {};
2180    TempCtor.prototype = superCtor.prototype;
2181    ctor.prototype = new TempCtor();
2182    ctor.prototype.constructor = ctor;
2183  }
2184
2185  // BN
2186
2187  function BN (number, base, endian) {
2188    if (BN.isBN(number)) {
2189      return number;
2190    }
2191
2192    this.negative = 0;
2193    this.words = null;
2194    this.length = 0;
2195
2196    // Reduction context
2197    this.red = null;
2198
2199    if (number !== null) {
2200      if (base === 'le' || base === 'be') {
2201        endian = base;
2202        base = 10;
2203      }
2204
2205      this._init(number || 0, base || 10, endian || 'be');
2206    }
2207  }
2208  if (typeof module === 'object') {
2209    module.exports = BN;
2210  } else {
2211    exports.BN = BN;
2212  }
2213
2214  BN.BN = BN;
2215  BN.wordSize = 26;
2216
2217  var Buffer;
2218  try {
2219    Buffer = __webpack_require__(0).Buffer;
2220  } catch (e) {
2221  }
2222
2223  BN.isBN = function isBN (num) {
2224    if (num instanceof BN) {
2225      return true;
2226    }
2227
2228    return num !== null && typeof num === 'object' &&
2229      num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
2230  };
2231
2232  BN.max = function max (left, right) {
2233    if (left.cmp(right) > 0) return left;
2234    return right;
2235  };
2236
2237  BN.min = function min (left, right) {
2238    if (left.cmp(right) < 0) return left;
2239    return right;
2240  };
2241
2242  BN.prototype._init = function init (number, base, endian) {
2243    if (typeof number === 'number') {
2244      return this._initNumber(number, base, endian);
2245    }
2246
2247    if (typeof number === 'object') {
2248      return this._initArray(number, base, endian);
2249    }
2250
2251    if (base === 'hex') {
2252      base = 16;
2253    }
2254    assert(base === (base | 0) && base >= 2 && base <= 36);
2255
2256    number = number.toString().replace(/\s+/g, '');
2257    var start = 0;
2258    if (number[0] === '-') {
2259      start++;
2260    }
2261
2262    if (base === 16) {
2263      this._parseHex(number, start);
2264    } else {
2265      this._parseBase(number, base, start);
2266    }
2267
2268    if (number[0] === '-') {
2269      this.negative = 1;
2270    }
2271
2272    this.strip();
2273
2274    if (endian !== 'le') return;
2275
2276    this._initArray(this.toArray(), base, endian);
2277  };
2278
2279  BN.prototype._initNumber = function _initNumber (number, base, endian) {
2280    if (number < 0) {
2281      this.negative = 1;
2282      number = -number;
2283    }
2284    if (number < 0x4000000) {
2285      this.words = [ number & 0x3ffffff ];
2286      this.length = 1;
2287    } else if (number < 0x10000000000000) {
2288      this.words = [
2289        number & 0x3ffffff,
2290        (number / 0x4000000) & 0x3ffffff
2291      ];
2292      this.length = 2;
2293    } else {
2294      assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)
2295      this.words = [
2296        number & 0x3ffffff,
2297        (number / 0x4000000) & 0x3ffffff,
2298        1
2299      ];
2300      this.length = 3;
2301    }
2302
2303    if (endian !== 'le') return;
2304
2305    // Reverse the bytes
2306    this._initArray(this.toArray(), base, endian);
2307  };
2308
2309  BN.prototype._initArray = function _initArray (number, base, endian) {
2310    // Perhaps a Uint8Array
2311    assert(typeof number.length === 'number');
2312    if (number.length <= 0) {
2313      this.words = [ 0 ];
2314      this.length = 1;
2315      return this;
2316    }
2317
2318    this.length = Math.ceil(number.length / 3);
2319    this.words = new Array(this.length);
2320    for (var i = 0; i < this.length; i++) {
2321      this.words[i] = 0;
2322    }
2323
2324    var j, w;
2325    var off = 0;
2326    if (endian === 'be') {
2327      for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
2328        w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);
2329        this.words[j] |= (w << off) & 0x3ffffff;
2330        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
2331        off += 24;
2332        if (off >= 26) {
2333          off -= 26;
2334          j++;
2335        }
2336      }
2337    } else if (endian === 'le') {
2338      for (i = 0, j = 0; i < number.length; i += 3) {
2339        w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);
2340        this.words[j] |= (w << off) & 0x3ffffff;
2341        this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;
2342        off += 24;
2343        if (off >= 26) {
2344          off -= 26;
2345          j++;
2346        }
2347      }
2348    }
2349    return this.strip();
2350  };
2351
2352  function parseHex (str, start, end) {
2353    var r = 0;
2354    var len = Math.min(str.length, end);
2355    for (var i = start; i < len; i++) {
2356      var c = str.charCodeAt(i) - 48;
2357
2358      r <<= 4;
2359
2360      // 'a' - 'f'
2361      if (c >= 49 && c <= 54) {
2362        r |= c - 49 + 0xa;
2363
2364      // 'A' - 'F'
2365      } else if (c >= 17 && c <= 22) {
2366        r |= c - 17 + 0xa;
2367
2368      // '0' - '9'
2369      } else {
2370        r |= c & 0xf;
2371      }
2372    }
2373    return r;
2374  }
2375
2376  BN.prototype._parseHex = function _parseHex (number, start) {
2377    // Create possibly bigger array to ensure that it fits the number
2378    this.length = Math.ceil((number.length - start) / 6);
2379    this.words = new Array(this.length);
2380    for (var i = 0; i < this.length; i++) {
2381      this.words[i] = 0;
2382    }
2383
2384    var j, w;
2385    // Scan 24-bit chunks and add them to the number
2386    var off = 0;
2387    for (i = number.length - 6, j = 0; i >= start; i -= 6) {
2388      w = parseHex(number, i, i + 6);
2389      this.words[j] |= (w << off) & 0x3ffffff;
2390      // NOTE: `0x3fffff` is intentional here, 26bits max shift + 24bit hex limb
2391      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
2392      off += 24;
2393      if (off >= 26) {
2394        off -= 26;
2395        j++;
2396      }
2397    }
2398    if (i + 6 !== start) {
2399      w = parseHex(number, start, i + 6);
2400      this.words[j] |= (w << off) & 0x3ffffff;
2401      this.words[j + 1] |= w >>> (26 - off) & 0x3fffff;
2402    }
2403    this.strip();
2404  };
2405
2406  function parseBase (str, start, end, mul) {
2407    var r = 0;
2408    var len = Math.min(str.length, end);
2409    for (var i = start; i < len; i++) {
2410      var c = str.charCodeAt(i) - 48;
2411
2412      r *= mul;
2413
2414      // 'a'
2415      if (c >= 49) {
2416        r += c - 49 + 0xa;
2417
2418      // 'A'
2419      } else if (c >= 17) {
2420        r += c - 17 + 0xa;
2421
2422      // '0' - '9'
2423      } else {
2424        r += c;
2425      }
2426    }
2427    return r;
2428  }
2429
2430  BN.prototype._parseBase = function _parseBase (number, base, start) {
2431    // Initialize as zero
2432    this.words = [ 0 ];
2433    this.length = 1;
2434
2435    // Find length of limb in base
2436    for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {
2437      limbLen++;
2438    }
2439    limbLen--;
2440    limbPow = (limbPow / base) | 0;
2441
2442    var total = number.length - start;
2443    var mod = total % limbLen;
2444    var end = Math.min(total, total - mod) + start;
2445
2446    var word = 0;
2447    for (var i = start; i < end; i += limbLen) {
2448      word = parseBase(number, i, i + limbLen, base);
2449
2450      this.imuln(limbPow);
2451      if (this.words[0] + word < 0x4000000) {
2452        this.words[0] += word;
2453      } else {
2454        this._iaddn(word);
2455      }
2456    }
2457
2458    if (mod !== 0) {
2459      var pow = 1;
2460      word = parseBase(number, i, number.length, base);
2461
2462      for (i = 0; i < mod; i++) {
2463        pow *= base;
2464      }
2465
2466      this.imuln(pow);
2467      if (this.words[0] + word < 0x4000000) {
2468        this.words[0] += word;
2469      } else {
2470        this._iaddn(word);
2471      }
2472    }

2472
2473  };
2474
2475  BN.prototype.copy = function copy (dest) {
2476    dest.words = new Array(this.length);
2477    for (var i = 0; i < this.length; i++) {
2478      dest.words[i] = this.words[i];
2479    }
2480    dest.length = this.length;
2481    dest.negative = this.negative;
2482    dest.red = this.red;
2483  };
2484
2485  BN.prototype.clone = function clone () {
2486    var r = new BN(null);
2487    this.copy(r);
2488    return r;
2489  };
2490
2491  BN.prototype._expand = function _expand (size) {
2492    while (this.length < size) {
2493      this.words[this.length++] = 0;
2494    }
2495    return this;
2496  };
2497
2498  // Remove leading `0` from `this`
2499  BN.prototype.strip = function strip () {
2500    while (this.length > 1 && this.words[this.length - 1] === 0) {
2501      this.length--;
2502    }
2503    return this._normSign();
2504  };
2505
2506  BN.prototype._normSign = function _normSign () {
2507    // -0 = 0
2508    if (this.length === 1 && this.words[0] === 0) {
2509      this.negative = 0;
2510    }
2511    return this;
2512  };
2513
2514  BN.prototype.inspect = function inspect () {
2515    return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
2516  };
2517
2518  /*
2519
2520  var zeros = [];
2521  var groupSizes = [];
2522  var groupBases = [];
2523
2524  var s = '';
2525  var i = -1;
2526  while (++i < BN.wordSize) {
2527    zeros[i] = s;
2528    s += '0';
2529  }
2530  groupSizes[0] = 0;
2531  groupSizes[1] = 0;
2532  groupBases[0] = 0;
2533  groupBases[1] = 0;
2534  var base = 2 - 1;
2535  while (++base < 36 + 1) {
2536    var groupSize = 0;
2537    var groupBase = 1;
2538    while (groupBase < (1 << BN.wordSize) / base) {
2539      groupBase *= base;
2540      groupSize += 1;
2541    }
2542    groupSizes[base] = groupSize;
2543    groupBases[base] = groupBase;
2544  }
2545
2546  */
2547
2548  var zeros = [
2549    '',
2550    '0',
2551    '00',
2552    '000',
2553    '0000',
2554    '00000',
2555    '000000',
2556    '0000000',
2557    '00000000',
2558    '000000000',
2559    '0000000000',
2560    '00000000000',
2561    '000000000000',
2562    '0000000000000',
2563    '00000000000000',
2564    '000000000000000',
2565    '0000000000000000',
2566    '00000000000000000',
2567    '000000000000000000',
2568    '0000000000000000000',
2569    '00000000000000000000',
2570    '000000000000000000000',
2571    '0000000000000000000000',
2572    '00000000000000000000000',
2573    '000000000000000000000000',
2574    '0000000000000000000000000'
2575  ];
2576
2577  var groupSizes = [
2578    0, 0,
2579    25, 16, 12, 11, 10, 9, 8,
2580    8, 7, 7, 7, 7, 6, 6,
2581    6, 6, 6, 6, 6, 5, 5,
2582    5, 5, 5, 5, 5, 5, 5,
2583    5, 5, 5, 5, 5, 5, 5
2584  ];
2585
2586  var groupBases = [
2587    0, 0,
2588    33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,
2589    43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,
2590    16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,
2591    6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,
2592    24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176
2593  ];
2594
2595  BN.prototype.toString = function toString (base, padding) {
2596    base = base || 10;
2597    padding = padding | 0 || 1;
2598
2599    var out;
2600    if (base === 16 || base === 'hex') {
2601      out = '';
2602      var off = 0;
2603      var carry = 0;
2604      for (var i = 0; i < this.length; i++) {
2605        var w = this.words[i];
2606        var word = (((w << off) | carry) & 0xffffff).toString(16);
2607        carry = (w >>> (24 - off)) & 0xffffff;
2608        if (carry !== 0 || i !== this.length - 1) {
2609          out = zeros[6 - word.length] + word + out;
2610        } else {
2611          out = word + out;
2612        }
2613        off += 2;
2614        if (off >= 26) {
2615          off -= 26;
2616          i--;
2617        }
2618      }
2619      if (carry !== 0) {
2620        out = carry.toString(16) + out;
2621      }
2622      while (out.length % padding !== 0) {
2623        out = '0' + out;
2624      }
2625      if (this.negative !== 0) {
2626        out = '-' + out;
2627      }
2628      return out;
2629    }
2630
2631    if (base === (base | 0) && base >= 2 && base <= 36) {
2632      // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));
2633      var groupSize = groupSizes[base];
2634      // var groupBase = Math.pow(base, groupSize);
2635      var groupBase = groupBases[base];
2636      out = '';
2637      var c = this.clone();
2638      c.negative = 0;
2639      while (!c.isZero()) {
2640        var r = c.modn(groupBase).toString(base);
2641        c = c.idivn(groupBase);
2642
2643        if (!c.isZero()) {
2644          out = zeros[groupSize - r.length] + r + out;
2645        } else {
2646          out = r + out;
2647        }
2648      }
2649      if (this.isZero()) {
2650        out = '0' + out;
2651      }
2652      while (out.length % padding !== 0) {
2653        out = '0' + out;
2654      }
2655      if (this.negative !== 0) {
2656        out = '-' + out;
2657      }
2658      return out;
2659    }
2660
2661    assert(false, 'Base should be between 2 and 36');
2662  };
2663
2664  BN.prototype.toNumber = function toNumber () {
2665    var ret = this.words[0];
2666    if (this.length === 2) {
2667      ret += this.words[1] * 0x4000000;
2668    } else if (this.length === 3 && this.words[2] === 0x01) {
2669      // NOTE: at this stage it is known that the top bit is set
2670      ret += 0x10000000000000 + (this.words[1] * 0x4000000);
2671    } else if (this.length > 2) {
2672      assert(false, 'Number can only safely store up to 53 bits');
2673    }
2674    return (this.negative !== 0) ? -ret : ret;
2675  };
2676
2677  BN.prototype.toJSON = function toJSON () {
2678    return this.toString(16);
2679  };
2680
2681  BN.prototype.toBuffer = function toBuffer (endian, length) {
2682    assert(typeof Buffer !== 'undefined');
2683    return this.toArrayLike(Buffer, endian, length);
2684  };
2685
2686  BN.prototype.toArray = function toArray (endian, length) {
2687    return this.toArrayLike(Array, endian, length);
2688  };
2689
2690  BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
2691    var byteLength = this.byteLength();
2692    var reqLength = length || Math.max(1, byteLength);
2693    assert(byteLength <= reqLength, 'byte array longer than desired length');
2694    assert(reqLength > 0, 'Requested array length <= 0');
2695
2696    this.strip();
2697    var littleEndian = endian === 'le';
2698    var res = new ArrayType(reqLength);
2699
2700    var b, i;
2701    var q = this.clone();
2702    if (!littleEndian) {
2703      // Assume big-endian
2704      for (i = 0; i < reqLength - byteLength; i++) {
2705        res[i] = 0;
2706      }
2707
2708      for (i = 0; !q.isZero(); i++) {
2709        b = q.andln(0xff);
2710        q.iushrn(8);
2711
2712        res[reqLength - i - 1] = b;
2713      }
2714    } else {
2715      for (i = 0; !q.isZero(); i++) {
2716        b = q.andln(0xff);
2717        q.iushrn(8);
2718
2719        res[i] = b;
2720      }
2721
2722      for (; i < reqLength; i++) {
2723        res[i] = 0;
2724      }
2725    }
2726
2727    return res;
2728  };
2729
2730  if (Math.clz32) {
2731    BN.prototype._countBits = function _countBits (w) {
2732      return 32 - Math.clz32(w);
2733    };
2734  } else {
2735    BN.prototype._countBits = function _countBits (w) {
2736      var t = w;
2737      var r = 0;
2738      if (t >= 0x1000) {
2739        r += 13;
2740        t >>>= 13;
2741      }
2742      if (t >= 0x40) {
2743        r += 7;
2744        t >>>= 7;
2745      }
2746      if (t >= 0x8) {
2747        r += 4;
2748        t >>>= 4;
2749      }
2750      if (t >= 0x02) {
2751        r += 2;
2752        t >>>= 2;
2753      }
2754      return r + t;
2755    };
2756  }
2757
2758  BN.prototype._zeroBits = function _zeroBits (w) {
2759    // Short-cut
2760    if (w === 0) return 26;
2761
2762    var t = w;
2763    var r = 0;
2764    if ((t & 0x1fff) === 0) {
2765      r += 13;
2766      t >>>= 13;
2767    }
2768    if ((t & 0x7f) === 0) {
2769      r += 7;
2770      t >>>= 7;
2771    }
2772    if ((t & 0xf) === 0) {
2773      r += 4;
2774      t >>>= 4;
2775    }
2776    if ((t & 0x3) === 0) {
2777      r += 2;
2778      t >>>= 2;
2779    }
2780    if ((t & 0x1) === 0) {
2781      r++;
2782    }
2783    return r;
2784  };
2785
2786  // Return number of used bits in a BN
2787  BN.prototype.bitLength = function bitLength () {
2788    var w = this.words[this.length - 1];
2789    var hi = this._countBits(w);
2790    return (this.length - 1) * 26 + hi;
2791  };
2792
2793  function toBitArray (num) {
2794    var w = new Array(num.bitLength());
2795
2796    for (var bit = 0; bit < w.length; bit++) {
2797      var off = (bit / 26) | 0;
2798      var wbit = bit % 26;
2799
2800      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
2801    }
2802
2803    return w;
2804  }
2805
2806  // Number of trailing zero bits
2807  BN.prototype.zeroBits = function zeroBits () {
2808    if (this.isZero()) return 0;
2809
2810    var r = 0;
2811    for (var i = 0; i < this.length; i++) {
2812      var b = this._zeroBits(this.words[i]);
2813      r += b;
2814      if (b !== 26) break;
2815    }
2816    return r;
2817  };
2818
2819  BN.prototype.byteLength = function byteLength () {
2820    return Math.ceil(this.bitLength() / 8);
2821  };
2822
2823  BN.prototype.toTwos = function toTwos (width) {
2824    if (this.negative !== 0) {
2825      return this.abs().inotn(width).iaddn(1);
2826    }
2827    return this.clone();
2828  };
2829
2830  BN.prototype.fromTwos = function fromTwos (width) {
2831    if (this.testn(width - 1)) {
2832      return this.notn(width).iaddn(1).ineg();
2833    }
2834    return this.clone();
2835  };
2836
2837  BN.prototype.isNeg = function isNeg () {
2838    return this.negative !== 0;
2839  };
2840
2841  // Return negative clone of `this`
2842  BN.prototype.neg = function neg () {
2843    return this.clone().ineg();
2844  };
2845
2846  BN.prototype.ineg = function ineg () {
2847    if (!this.isZero()) {
2848      this.negative ^= 1;
2849    }
2850
2851    return this;
2852  };
2853
2854  // Or `num` with `this` in-place
2855  BN.prototype.iuor = function iuor (num) {
2856    while (this.length < num.length) {
2857      this.words[this.length++] = 0;
2858    }
2859
2860    for (var i = 0; i < num.length; i++) {
2861      this.words[i] = this.words[i] | num.words[i];
2862    }
2863
2864    return this.strip();
2865  };
2866
2867  BN.prototype.ior = function ior (num) {
2868    assert((this.negative | num.negative) === 0);
2869    return this.iuor(num);
2870  };
2871
2872  // Or `num` with `this`
2873  BN.prototype.or = function or (num) {
2874    if (this.length > num.length) return this.clone().ior(num);
2875    return num.clone().ior(this);
2876  };
2877
2878  BN.prototype.uor = function uor (num) {
2879    if (this.length > num.length) return this.clone().iuor(num);
2880    return num.clone().iuor(this);
2881  };
2882
2883  // And `num` with `this` in-place
2884  BN.prototype.iuand = function iuand (num) {
2885    // b = min-length(num, this)
2886    var b;
2887    if (this.length > num.length) {
2888      b = num;
2889    } else {
2890      b = this;
2891    }
2892
2893    for (var i = 0; i < b.length; i++) {
2894      this.words[i] = this.words[i] & num.words[i];
2895    }
2896
2897    this.length = b.length;
2898
2899    return this.strip();
2900  };
2901
2902  BN.prototype.iand = function iand (num) {
2903    assert((this.negative | num.negative) === 0);
2904    return this.iuand(num);
2905  };
2906
2907  // And `num` with `this`
2908  BN.prototype.and = function and (num) {
2909    if (this.length > num.length) return this.clone().iand(num);
2910    return num.clone().iand(this);
2911  };
2912
2913  BN.prototype.uand = function uand (num) {
2914    if (this.length > num.length) return this.clone().iuand(num);
2915    return num.clone().iuand(this);
2916  };
2917
2918  // Xor `num` with `this` in-place
2919  BN.prototype.iuxor = function iuxor (num) {
2920    // a.length > b.length
2921    var a;
2922    var b;
2923    if (this.length > num.length) {
2924      a = this;
2925      b = num;
2926    } else {
2927      a = num;
2928      b = this;
2929    }
2930
2931    for (var i = 0; i < b.length; i++) {
2932      this.words[i] = a.words[i] ^ b.words[i];
2933    }
2934
2935    if (this !== a) {
2936      for (; i < a.length; i++) {
2937        this.words[i] = a.words[i];
2938      }
2939    }
2940
2941    this.length = a.length;
2942
2943    return this.strip();
2944  };
2945
2946  BN.prototype.ixor = function ixor (num) {
2947    assert((this.negative | num.negative) === 0);
2948    return this.iuxor(num);
2949  };
2950
2951  // Xor `num` with `this`
2952  BN.prototype.xor = function xor (num) {
2953    if (this.length > num.length) return this.clone().ixor(num);
2954    return num.clone().ixor(this);
2955  };
2956
2957  BN.prototype.uxor = function uxor (num) {
2958    if (this.length > num.length) return this.clone().iuxor(num);
2959    return num.clone().iuxor(this);
2960  };
2961
2962  // Not ``this`` with ``width`` bitwidth
2963  BN.prototype.inotn = function inotn (width) {
2964    assert(typeof width === 'number' && width >= 0);
2965
2966    var bytesNeeded = Math.ceil(width / 26) | 0;
2967    var bitsLeft = width % 26;
2968
2969    // Extend the buffer with leading zeroes
2970    this._expand(bytesNeeded);
2971
2972    if (bitsLeft > 0) {
2973      bytesNeeded--;
2974    }
2975
2976    // Handle complete words
2977    for (var i = 0; i < bytesNeeded; i++) {
2978      this.words[i] = ~this.words[i] & 0x3ffffff;
2979    }
2980
2981    // Handle the residue
2982    if (bitsLeft > 0) {
2983      this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));
2984    }
2985
2986    // And remove leading zeroes
2987    return this.strip();
2988  };
2989
2990  BN.prototype.notn = function notn (width) {
2991    return this.clone().inotn(width);
2992  };
2993
2994  // Set `bit` of `this`
2995  BN.prototype.setn = function setn (bit, val) {
2996    assert(typeof bit === 'number' && bit >= 0);
2997
2998    var off = (bit / 26) | 0;
2999    var wbit = bit % 26;
3000
3001    this._expand(off + 1);
3002
3003    if (val) {
3004      this.words[off] = this.words[off] | (1 << wbit);
3005    } else {
3006      this.words[off] = this.words[off] & ~(1 << wbit);
3007    }
3008
3009    return this.strip();
3010  };
3011
3012  // Add `num` to `this` in-place
3013  BN.prototype.iadd = function iadd (num) {
3014    var r;
3015
3016    // negative + positive
3017    if (this.negative !== 0 && num.negative === 0) {
3018      this.negative = 0;
3019      r = this.isub(num);
3020      this.negative ^= 1;
3021      return this._normSign();
3022
3023    // positive + negative
3024    } else if (this.negative === 0 && num.negative !== 0) {
3025      num.negative = 0;
3026      r = this.isub(num);
3027      num.negative = 1;
3028      return r._normSign();
3029    }
3030
3031    // a.length > b.length
3032    var a, b;
3033    if (this.length > num.length) {
3034      a = this;
3035      b = num;
3036    } else {
3037      a = num;
3038      b = this;
3039    }
3040
3041    var carry = 0;
3042    for (var i = 0; i < b.length; i++) {
3043      r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
3044      this.words[i] = r & 0x3ffffff;
3045      carry = r >>> 26;
3046    }
3047    for (; carry !== 0 && i < a.length; i++) {
3048      r = (a.words[i] | 0) + carry;
3049      this.words[i] = r & 0x3ffffff;
3050      carry = r >>> 26;
3051    }
3052
3053    this.length = a.length;
3054    if (carry !== 0) {
3055      this.words[this.length] = carry;
3056      this.length++;
3057    // Copy the rest of the words
3058    } else if (a !== this) {
3059      for (; i < a.length; i++) {
3060        this.words[i] = a.words[i];
3061      }
3062    }
3063
3064    return this;
3065  };
3066
3067  // Add `num` to `this`
3068  BN.prototype.add = function add (num) {
3069    var res;
3070    if (num.negative !== 0 && this.negative === 0) {
3071      num.negative = 0;
3072      res = this.sub(num);
3073      num.negative ^= 1;
3074      return res;
3075    } else if (num.negative === 0 && this.negative !== 0) {
3076      this.negative = 0;
3077      res = num.sub(this);
3078      this.negative = 1;
3079      return res;
3080    }
3081
3082    if (this.length > num.length) return this.clone().iadd(num);
3083
3084    return num.clone().iadd(this);
3085  };
3086
3087  // Subtract `num` from `this` in-place
3088  BN.prototype.isub = function isub (num) {
3089    // this - (-num) = this + num
3090    if (num.negative !== 0) {
3091      num.negative = 0;
3092      var r = this.iadd(num);
3093      num.negative = 1;
3094      return r._normSign();
3095
3096    // -this - num = -(this + num)
3097    } else if (this.negative !== 0) {
3098      this.negative = 0;
3099      this.iadd(num);
3100      this.negative = 1;
3101      return this._normSign();
3102    }
3103
3104    // At this point both numbers are positive
3105    var cmp = this.cmp(num);
3106
3107    // Optimization - zeroify
3108    if (cmp === 0) {
3109      this.negative = 0;
3110      this.length = 1;
3111      this.words[0] = 0;
3112      return this;
3113    }
3114
3115    // a > b
3116    var a, b;
3117    if (cmp > 0) {
3118      a = this;
3119      b = num;
3120    } else {
3121      a = num;
3122      b = this;
3123    }
3124
3125    var carry = 0;
3126    for (var i = 0; i < b.length; i++) {
3127      r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
3128      carry = r >> 26;
3129      this.words[i] = r & 0x3ffffff;
3130    }
3131    for (; carry !== 0 && i < a.length; i++) {
3132      r = (a.words[i] | 0) + carry;
3133      carry = r >> 26;
3134      this.words[i] = r & 0x3ffffff;
3135    }
3136
3137    // Copy rest of the words
3138    if (carry === 0 && i < a.length && a !== this) {
3139      for (; i < a.length; i++) {
3140        this.words[i] = a.words[i];
3141      }
3142    }
3143
3144    this.length = Math.max(this.length, i);
3145
3146    if (a !== this) {
3147      this.negative = 1;
3148    }
3149
3150    return this.strip();
3151  };
3152
3153  // Subtract `num` from `this`
3154  BN.prototype.sub = function sub (num) {
3155    return this.clone().isub(num);
3156  };
3157
3158  function smallMulTo (self, num, out) {
3159    out.negative = num.negative ^ self.negative;
3160    var len = (self.length + num.length) | 0;
3161    out.length = len;
3162    len = (len - 1) | 0;
3163
3164    // Peel one iteration (compiler can't do it, because of code complexity)
3165    var a = self.words[0] | 0;
3166    var b = num.words[0] | 0;
3167    var r = a * b;
3168
3169    var lo = r & 0x3ffffff;
3170    var carry = (r / 0x4000000) | 0;
3171    out.words[0] = lo;
3172
3173    for (var k = 1; k < len; k++) {
3174      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
3175      // note that ncarry could be >= 0x3ffffff
3176      var ncarry = carry >>> 26;
3177      var rword = carry & 0x3ffffff;
3178      var maxJ = Math.min(k, num.length - 1);
3179      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
3180        var i = (k - j) | 0;
3181        a = self.words[i] | 0;
3182        b = num.words[j] | 0;
3183        r = a * b + rword;
3184        ncarry += (r / 0x4000000) | 0;
3185        rword = r & 0x3ffffff;
3186      }
3187      out.words[k] = rword | 0;
3188      carry = ncarry | 0;
3189    }
3190    if (carry !== 0) {
3191      out.words[k] = carry | 0;
3192    } else {
3193      out.length--;
3194    }
3195
3196    return out.strip();
3197  }
3198
3199  // TODO(indutny): it may be reasonable to omit it for users who don't need
3200  // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit
3201  // multiplication (like elliptic secp256k1).
3202  var comb10MulTo = function comb10MulTo (self, num, out) {
3203    var a = self.words;
3204    var b = num.words;
3205    var o = out.words;
3206    var c = 0;
3207    var lo;
3208    var mid;
3209    var hi;
3210    var a0 = a[0] | 0;
3211    var al0 = a0 & 0x1fff;
3212    var ah0 = a0 >>> 13;
3213    var a1 = a[1] | 0;
3214    var al1 = a1 & 0x1fff;
3215    var ah1 = a1 >>> 13;
3216    var a2 = a[2] | 0;
3217    var al2 = a2 & 0x1fff;
3218    var ah2 = a2 >>> 13;
3219    var a3 = a[3] | 0;
3220    var al3 = a3 & 0x1fff;
3221    var ah3 = a3 >>> 13;
3222    var a4 = a[4] | 0;
3223    var al4 = a4 & 0x1fff;
3224    var ah4 = a4 >>> 13;
3225    var a5 = a[5] | 0;
3226    var al5 = a5 & 0x1fff;
3227    var ah5 = a5 >>> 13;
3228    var a6 = a[6] | 0;
3229    var al6 = a6 & 0x1fff;
3230    var ah6 = a6 >>> 13;
3231    var a7 = a[7] | 0;
3232    var al7 = a7 & 0x1fff;
3233    var ah7 = a7 >>> 13;
3234    var a8 = a[8] | 0;
3235    var al8 = a8 & 0x1fff;
3236    var ah8 = a8 >>> 13;
3237    var a9 = a[9] | 0;
3238    var al9 = a9 & 0x1fff;
3239    var ah9 = a9 >>> 13;
3240    var b0 = b[0] | 0;
3241    var bl0 = b0 & 0x1fff;
3242    var bh0 = b0 >>> 13;
3243    var b1 = b[1] | 0;
3244    var bl1 = b1 & 0x1fff;
3245    var bh1 = b1 >>> 13;
3246    var b2 = b[2] | 0;
3247    var bl2 = b2 & 0x1fff;
3248    var bh2 = b2 >>> 13;
3249    var b3 = b[3] | 0;
3250    var bl3 = b3 & 0x1fff;
3251    var bh3 = b3 >>> 13;
3252    var b4 = b[4] | 0;
3253    var bl4 = b4 & 0x1fff;
3254    var bh4 = b4 >>> 13;
3255    var b5 = b[5] | 0;
3256    var bl5 = b5 & 0x1fff;
3257    var bh5 = b5 >>> 13;
3258    var b6 = b[6] | 0;
3259    var bl6 = b6 & 0x1fff;
3260    var bh6 = b6 >>> 13;
3261    var b7 = b[7] | 0;
3262    var bl7 = b7 & 0x1fff;
3263    var bh7 = b7 >>> 13;
3264    var b8 = b[8] | 0;
3265    var bl8 = b8 & 0x1fff;
3266    var bh8 = b8 >>> 13;
3267    var b9 = b[9] | 0;
3268    var bl9 = b9 & 0x1fff;
3269    var bh9 = b9 >>> 13;
3270
3271    out.negative = self.negative ^ num.negative;
3272    out.length = 19;
3273    /* k = 0 */
3274    lo = Math.imul(al0, bl0);
3275    mid = Math.imul(al0, bh0);
3276    mid = (mid + Math.imul(ah0, bl0)) | 0;
3277    hi = Math.imul(ah0, bh0);
3278    var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3279    c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;
3280    w0 &= 0x3ffffff;
3281    /* k = 1 */
3282    lo = Math.imul(al1, bl0);
3283    mid = Math.imul(al1, bh0);
3284    mid = (mid + Math.imul(ah1, bl0)) | 0;
3285    hi = Math.imul(ah1, bh0);
3286    lo = (lo + Math.imul(al0, bl1)) | 0;
3287    mid = (mid + Math.imul(al0, bh1)) | 0;
3288    mid = (mid + Math.imul(ah0, bl1)) | 0;
3289    hi = (hi + Math.imul(ah0, bh1)) | 0;
3290    var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3291    c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;
3292    w1 &= 0x3ffffff;
3293    /* k = 2 */
3294    lo = Math.imul(al2, bl0);
3295    mid = Math.imul(al2, bh0);
3296    mid = (mid + Math.imul(ah2, bl0)) | 0;
3297    hi = Math.imul(ah2, bh0);
3298    lo = (lo + Math.imul(al1, bl1)) | 0;
3299    mid = (mid + Math.imul(al1, bh1)) | 0;
3300    mid = (mid + Math.imul(ah1, bl1)) | 0;
3301    hi = (hi + Math.imul(ah1, bh1)) | 0;
3302    lo = (lo + Math.imul(al0, bl2)) | 0;
3303    mid = (mid + Math.imul(al0, bh2)) | 0;
3304    mid = (mid + Math.imul(ah0, bl2)) | 0;
3305    hi = (hi + Math.imul(ah0, bh2)) | 0;
3306    var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3307    c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;
3308    w2 &= 0x3ffffff;
3309    /* k = 3 */
3310    lo = Math.imul(al3, bl0);
3311    mid = Math.imul(al3, bh0);
3312    mid = (mid + Math.imul(ah3, bl0)) | 0;
3313    hi = Math.imul(ah3, bh0);
3314    lo = (lo + Math.imul(al2, bl1)) | 0;
3315    mid = (mid + Math.imul(al2, bh1)) | 0;
3316    mid = (mid + Math.imul(ah2, bl1)) | 0;
3317    hi = (hi + Math.imul(ah2, bh1)) | 0;
3318    lo = (lo + Math.imul(al1, bl2)) | 0;
3319    mid = (mid + Math.imul(al1, bh2)) | 0;
3320    mid = (mid + Math.imul(ah1, bl2)) | 0;
3321    hi = (hi + Math.imul(ah1, bh2)) | 0;
3322    lo = (lo + Math.imul(al0, bl3)) | 0;
3323    mid = (mid + Math.imul(al0, bh3)) | 0;
3324    mid = (mid + Math.imul(ah0, bl3)) | 0;
3325    hi = (hi + Math.imul(ah0, bh3)) | 0;
3326    var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3327    c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;
3328    w3 &= 0x3ffffff;
3329    /* k = 4 */
3330    lo = Math.imul(al4, bl0);
3331    mid = Math.imul(al4, bh0);
3332    mid = (mid + Math.imul(ah4, bl0)) | 0;
3333    hi = Math.imul(ah4, bh0);
3334    lo = (lo + Math.imul(al3, bl1)) | 0;
3335    mid = (mid + Math.imul(al3, bh1)) | 0;
3336    mid = (mid + Math.imul(ah3, bl1)) | 0;
3337    hi = (hi + Math.imul(ah3, bh1)) | 0;
3338    lo = (lo + Math.imul(al2, bl2)) | 0;
3339    mid = (mid + Math.imul(al2, bh2)) | 0;
3340    mid = (mid + Math.imul(ah2, bl2)) | 0;
3341    hi = (hi + Math.imul(ah2, bh2)) | 0;
3342    lo = (lo + Math.imul(al1, bl3)) | 0;
3343    mid = (mid + Math.imul(al1, bh3)) | 0;
3344    mid = (mid + Math.imul(ah1, bl3)) | 0;
3345    hi = (hi + Math.imul(ah1, bh3)) | 0;
3346    lo = (lo + Math.imul(al0, bl4)) | 0;
3347    mid = (mid + Math.imul(al0, bh4)) | 0;
3348    mid = (mid + Math.imul(ah0, bl4)) | 0;
3349    hi = (hi + Math.imul(ah0, bh4)) | 0;
3350    var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3351    c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;
3352    w4 &= 0x3ffffff;
3353    /* k = 5 */
3354    lo = Math.imul(al5, bl0);
3355    mid = Math.imul(al5, bh0);
3356    mid = (mid + Math.imul(ah5, bl0)) | 0;
3357    hi = Math.imul(ah5, bh0);
3358    lo = (lo + Math.imul(al4, bl1)) | 0;
3359    mid = (mid + Math.imul(al4, bh1)) | 0;
3360    mid = (mid + Math.imul(ah4, bl1)) | 0;
3361    hi = (hi + Math.imul(ah4, bh1)) | 0;
3362    lo = (lo + Math.imul(al3, bl2)) | 0;
3363    mid = (mid + Math.imul(al3, bh2)) | 0;
3364    mid = (mid + Math.imul(ah3, bl2)) | 0;
3365    hi = (hi + Math.imul(ah3, bh2)) | 0;
3366    lo = (lo + Math.imul(al2, bl3)) | 0;
3367    mid = (mid + Math.imul(al2, bh3)) | 0;
3368    mid = (mid + Math.imul(ah2, bl3)) | 0;
3369    hi = (hi + Math.imul(ah2, bh3)) | 0;
3370    lo = (lo + Math.imul(al1, bl4)) | 0;
3371    mid = (mid + Math.imul(al1, bh4)) | 0;
3372    mid = (mid + Math.imul(ah1, bl4)) | 0;
3373    hi = (hi + Math.imul(ah1, bh4)) | 0;
3374    lo = (lo + Math.imul(al0, bl5)) | 0;
3375    mid = (mid + Math.imul(al0, bh5)) | 0;
3376    mid = (mid + Math.imul(ah0, bl5)) | 0;
3377    hi = (hi + Math.imul(ah0, bh5)) | 0;
3378    var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3379    c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;
3380    w5 &= 0x3ffffff;
3381    /* k = 6 */
3382    lo = Math.imul(al6, bl0);
3383    mid = Math.imul(al6, bh0);
3384    mid = (mid + Math.imul(ah6, bl0)) | 0;
3385    hi = Math.imul(ah6, bh0);
3386    lo = (lo + Math.imul(al5, bl1)) | 0;
3387    mid = (mid + Math.imul(al5, bh1)) | 0;
3388    mid = (mid + Math.imul(ah5, bl1)) | 0;
3389    hi = (hi + Math.imul(ah5, bh1)) | 0;
3390    lo = (lo + Math.imul(al4, bl2)) | 0;
3391    mid = (mid + Math.imul(al4, bh2)) | 0;
3392    mid = (mid + Math.imul(ah4, bl2)) | 0;
3393    hi = (hi + Math.imul(ah4, bh2)) | 0;
3394    lo = (lo + Math.imul(al3, bl3)) | 0;
3395    mid = (mid + Math.imul(al3, bh3)) | 0;
3396    mid = (mid + Math.imul(ah3, bl3)) | 0;
3397    hi = (hi + Math.imul(ah3, bh3)) | 0;
3398    lo = (lo + Math.imul(al2, bl4)) | 0;
3399    mid = (mid + Math.imul(al2, bh4)) | 0;
3400    mid = (mid + Math.imul(ah2, bl4)) | 0;
3401    hi = (hi + Math.imul(ah2, bh4)) | 0;
3402    lo = (lo + Math.imul(al1, bl5)) | 0;
3403    mid = (mid + Math.imul(al1, bh5)) | 0;
3404    mid = (mid + Math.imul(ah1, bl5)) | 0;
3405    hi = (hi + Math.imul(ah1, bh5)) | 0;
3406    lo = (lo + Math.imul(al0, bl6)) | 0;
3407    mid = (mid + Math.imul(al0, bh6)) | 0;
3408    mid = (mid + Math.imul(ah0, bl6)) | 0;
3409    hi = (hi + Math.imul(ah0, bh6)) | 0;
3410    var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3411    c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;
3412    w6 &= 0x3ffffff;
3413    /* k = 7 */
3414    lo = Math.imul(al7, bl0);
3415    mid = Math.imul(al7, bh0);
3416    mid = (mid + Math.imul(ah7, bl0)) | 0;
3417    hi = Math.imul(ah7, bh0);
3418    lo = (lo + Math.imul(al6, bl1)) | 0;
3419    mid = (mid + Math.imul(al6, bh1)) | 0;
3420    mid = (mid + Math.imul(ah6, bl1)) | 0;
3421    hi = (hi + Math.imul(ah6, bh1)) | 0;
3422    lo = (lo + Math.imul(al5, bl2)) | 0;
3423    mid = (mid + Math.imul(al5, bh2)) | 0;
3424    mid = (mid + Math.imul(ah5, bl2)) | 0;
3425    hi = (hi + Math.imul(ah5, bh2)) | 0;
3426    lo = (lo + Math.imul(al4, bl3)) | 0;
3427    mid = (mid + Math.imul(al4, bh3)) | 0;
3428    mid = (mid + Math.imul(ah4, bl3)) | 0;
3429    hi = (hi + Math.imul(ah4, bh3)) | 0;
3430    lo = (lo + Math.imul(al3, bl4)) | 0;
3431    mid = (mid + Math.imul(al3, bh4)) | 0;
3432    mid = (mid + Math.imul(ah3, bl4)) | 0;
3433    hi = (hi + Math.imul(ah3, bh4)) | 0;
3434    lo = (lo + Math.imul(al2, bl5)) | 0;
3435    mid = (mid + Math.imul(al2, bh5)) | 0;
3436    mid = (mid + Math.imul(ah2, bl5)) | 0;
3437    hi = (hi + Math.imul(ah2, bh5)) | 0;
3438    lo = (lo + Math.imul(al1, bl6)) | 0;
3439    mid = (mid + Math.imul(al1, bh6)) | 0;
3440    mid = (mid + Math.imul(ah1, bl6)) | 0;
3441    hi = (hi + Math.imul(ah1, bh6)) | 0;
3442    lo = (lo + Math.imul(al0, bl7)) | 0;
3443    mid = (mid + Math.imul(al0, bh7)) | 0;
3444    mid = (mid + Math.imul(ah0, bl7)) | 0;
3445    hi = (hi + Math.imul(ah0, bh7)) | 0;
3446    var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3447    c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;
3448    w7 &= 0x3ffffff;
3449    /* k = 8 */
3450    lo = Math.imul(al8, bl0);
3451    mid = Math.imul(al8, bh0);
3452    mid = (mid + Math.imul(ah8, bl0)) | 0;
3453    hi = Math.imul(ah8, bh0);
3454    lo = (lo + Math.imul(al7, bl1)) | 0;
3455    mid = (mid + Math.imul(al7, bh1)) | 0;
3456    mid = (mid + Math.imul(ah7, bl1)) | 0;
3457    hi = (hi + Math.imul(ah7, bh1)) | 0;
3458    lo = (lo + Math.imul(al6, bl2)) | 0;
3459    mid = (mid + Math.imul(al6, bh2)) | 0;
3460    mid = (mid + Math.imul(ah6, bl2)) | 0;
3461    hi = (hi + Math.imul(ah6, bh2)) | 0;
3462    lo = (lo + Math.imul(al5, bl3)) | 0;
3463    mid = (mid + Math.imul(al5, bh3)) | 0;
3464    mid = (mid + Math.imul(ah5, bl3)) | 0;
3465    hi = (hi + Math.imul(ah5, bh3)) | 0;
3466    lo = (lo + Math.imul(al4, bl4)) | 0;
3467    mid = (mid + Math.imul(al4, bh4)) | 0;
3468    mid = (mid + Math.imul(ah4, bl4)) | 0;
3469    hi = (hi + Math.imul(ah4, bh4)) | 0;
3470    lo = (lo + Math.imul(al3, bl5)) | 0;
3471    mid = (mid + Math.imul(al3, bh5)) | 0;
3472    mid = (mid + Math.imul(ah3, bl5)) | 0;
3473    hi = (hi + Math.imul(ah3, bh5)) | 0;
3474    lo = (lo + Math.imul(al2, bl6)) | 0;
3475    mid = (mid + Math.imul(al2, bh6)) | 0;
3476    mid = (mid + Math.imul(ah2, bl6)) | 0;
3477    hi = (hi + Math.imul(ah2, bh6)) | 0;
3478    lo = (lo + Math.imul(al1, bl7)) | 0;
3479    mid = (mid + Math.imul(al1, bh7)) | 0;
3480    mid = (mid + Math.imul(ah1, bl7)) | 0;
3481    hi = (hi + Math.imul(ah1, bh7)) | 0;
3482    lo = (lo + Math.imul(al0, bl8)) | 0;
3483    mid = (mid + Math.imul(al0, bh8)) | 0;
3484    mid = (mid + Math.imul(ah0, bl8)) | 0;
3485    hi = (hi + Math.imul(ah0, bh8)) | 0;
3486    var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3487    c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;
3488    w8 &= 0x3ffffff;
3489    /* k = 9 */
3490    lo = Math.imul(al9, bl0);
3491    mid = Math.imul(al9, bh0);
3492    mid = (mid + Math.imul(ah9, bl0)) | 0;
3493    hi = Math.imul(ah9, bh0);
3494    lo = (lo + Math.imul(al8, bl1)) | 0;
3495    mid = (mid + Math.imul(al8, bh1)) | 0;
3496    mid = (mid + Math.imul(ah8, bl1)) | 0;
3497    hi = (hi + Math.imul(ah8, bh1)) | 0;
3498    lo = (lo + Math.imul(al7, bl2)) | 0;
3499    mid = (mid + Math.imul(al7, bh2)) | 0;
3500    mid = (mid + Math.imul(ah7, bl2)) | 0;
3501    hi = (hi + Math.imul(ah7, bh2)) | 0;
3502    lo = (lo + Math.imul(al6, bl3)) | 0;
3503    mid = (mid + Math.imul(al6, bh3)) | 0;
3504    mid = (mid + Math.imul(ah6, bl3)) | 0;
3505    hi = (hi + Math.imul(ah6, bh3)) | 0;
3506    lo = (lo + Math.imul(al5, bl4)) | 0;
3507    mid = (mid + Math.imul(al5, bh4)) | 0;
3508    mid = (mid + Math.imul(ah5, bl4)) | 0;
3509    hi = (hi + Math.imul(ah5, bh4)) | 0;
3510    lo = (lo + Math.imul(al4, bl5)) | 0;
3511    mid = (mid + Math.imul(al4, bh5)) | 0;
3512    mid = (mid + Math.imul(ah4, bl5)) | 0;
3513    hi = (hi + Math.imul(ah4, bh5)) | 0;
3514    lo = (lo + Math.imul(al3, bl6)) | 0;
3515    mid = (mid + Math.imul(al3, bh6)) | 0;
3516    mid = (mid + Math.imul(ah3, bl6)) | 0;
3517    hi = (hi + Math.imul(ah3, bh6)) | 0;
3518    lo = (lo + Math.imul(al2, bl7)) | 0;
3519    mid = (mid + Math.imul(al2, bh7)) | 0;
3520    mid = (mid + Math.imul(ah2, bl7)) | 0;
3521    hi = (hi + Math.imul(ah2, bh7)) | 0;
3522    lo = (lo + Math.imul(al1, bl8)) | 0;
3523    mid = (mid + Math.imul(al1, bh8)) | 0;
3524    mid = (mid + Math.imul(ah1, bl8)) | 0;
3525    hi = (hi + Math.imul(ah1, bh8)) | 0;
3526    lo = (lo + Math.imul(al0, bl9)) | 0;
3527    mid = (mid + Math.imul(al0, bh9)) | 0;
3528    mid = (mid + Math.imul(ah0, bl9)) | 0;
3529    hi = (hi + Math.imul(ah0, bh9)) | 0;
3530    var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3531    c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;
3532    w9 &= 0x3ffffff;
3533    /* k = 10 */
3534    lo = Math.imul(al9, bl1);
3535    mid = Math.imul(al9, bh1);
3536    mid = (mid + Math.imul(ah9, bl1)) | 0;
3537    hi = Math.imul(ah9, bh1);
3538    lo = (lo + Math.imul(al8, bl2)) | 0;
3539    mid = (mid + Math.imul(al8, bh2)) | 0;
3540    mid = (mid + Math.imul(ah8, bl2)) | 0;
3541    hi = (hi + Math.imul(ah8, bh2)) | 0;
3542    lo = (lo + Math.imul(al7, bl3)) | 0;
3543    mid = (mid + Math.imul(al7, bh3)) | 0;
3544    mid = (mid + Math.imul(ah7, bl3)) | 0;
3545    hi = (hi + Math.imul(ah7, bh3)) | 0;
3546    lo = (lo + Math.imul(al6, bl4)) | 0;
3547    mid = (mid + Math.imul(al6, bh4)) | 0;
3548    mid = (mid + Math.imul(ah6, bl4)) | 0;
3549    hi = (hi + Math.imul(ah6, bh4)) | 0;
3550    lo = (lo + Math.imul(al5, bl5)) | 0;
3551    mid = (mid + Math.imul(al5, bh5)) | 0;
3552    mid = (mid + Math.imul(ah5, bl5)) | 0;
3553    hi = (hi + Math.imul(ah5, bh5)) | 0;
3554    lo = (lo + Math.imul(al4, bl6)) | 0;
3555    mid = (mid + Math.imul(al4, bh6)) | 0;
3556    mid = (mid + Math.imul(ah4, bl6)) | 0;
3557    hi = (hi + Math.imul(ah4, bh6)) | 0;
3558    lo = (lo + Math.imul(al3, bl7)) | 0;
3559    mid = (mid + Math.imul(al3, bh7)) | 0;
3560    mid = (mid + Math.imul(ah3, bl7)) | 0;
3561    hi = (hi + Math.imul(ah3, bh7)) | 0;
3562    lo = (lo + Math.imul(al2, bl8)) | 0;
3563    mid = (mid + Math.imul(al2, bh8)) | 0;
3564    mid = (mid + Math.imul(ah2, bl8)) | 0;
3565    hi = (hi + Math.imul(ah2, bh8)) | 0;
3566    lo = (lo + Math.imul(al1, bl9)) | 0;
3567    mid = (mid + Math.imul(al1, bh9)) | 0;
3568    mid = (mid + Math.imul(ah1, bl9)) | 0;
3569    hi = (hi + Math.imul(ah1, bh9)) | 0;
3570    var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3571    c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;
3572    w10 &= 0x3ffffff;
3573    /* k = 11 */
3574    lo = Math.imul(al9, bl2);
3575    mid = Math.imul(al9, bh2);
3576    mid = (mid + Math.imul(ah9, bl2)) | 0;
3577    hi = Math.imul(ah9, bh2);
3578    lo = (lo + Math.imul(al8, bl3)) | 0;
3579    mid = (mid + Math.imul(al8, bh3)) | 0;
3580    mid = (mid + Math.imul(ah8, bl3)) | 0;
3581    hi = (hi + Math.imul(ah8, bh3)) | 0;
3582    lo = (lo + Math.imul(al7, bl4)) | 0;
3583    mid = (mid + Math.imul(al7, bh4)) | 0;
3584    mid = (mid + Math.imul(ah7, bl4)) | 0;
3585    hi = (hi + Math.imul(ah7, bh4)) | 0;
3586    lo = (lo + Math.imul(al6, bl5)) | 0;
3587    mid = (mid + Math.imul(al6, bh5)) | 0;
3588    mid = (mid + Math.imul(ah6, bl5)) | 0;
3589    hi = (hi + Math.imul(ah6, bh5)) | 0;
3590    lo = (lo + Math.imul(al5, bl6)) | 0;
3591    mid = (mid + Math.imul(al5, bh6)) | 0;
3592    mid = (mid + Math.imul(ah5, bl6)) | 0;
3593    hi = (hi + Math.imul(ah5, bh6)) | 0;
3594    lo = (lo + Math.imul(al4, bl7)) | 0;
3595    mid = (mid + Math.imul(al4, bh7)) | 0;
3596    mid = (mid + Math.imul(ah4, bl7)) | 0;
3597    hi = (hi + Math.imul(ah4, bh7)) | 0;
3598    lo = (lo + Math.imul(al3, bl8)) | 0;
3599    mid = (mid + Math.imul(al3, bh8)) | 0;
3600    mid = (mid + Math.imul(ah3, bl8)) | 0;
3601    hi = (hi + Math.imul(ah3, bh8)) | 0;
3602    lo = (lo + Math.imul(al2, bl9)) | 0;
3603    mid = (mid + Math.imul(al2, bh9)) | 0;
3604    mid = (mid + Math.imul(ah2, bl9)) | 0;
3605    hi = (hi + Math.imul(ah2, bh9)) | 0;
3606    var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3607    c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;
3608    w11 &= 0x3ffffff;
3609    /* k = 12 */
3610    lo = Math.imul(al9, bl3);
3611    mid = Math.imul(al9, bh3);
3612    mid = (mid + Math.imul(ah9, bl3)) | 0;
3613    hi = Math.imul(ah9, bh3);
3614    lo = (lo + Math.imul(al8, bl4)) | 0;
3615    mid = (mid + Math.imul(al8, bh4)) | 0;
3616    mid = (mid + Math.imul(ah8, bl4)) | 0;
3617    hi = (hi + Math.imul(ah8, bh4)) | 0;
3618    lo = (lo + Math.imul(al7, bl5)) | 0;
3619    mid = (mid + Math.imul(al7, bh5)) | 0;
3620    mid = (mid + Math.imul(ah7, bl5)) | 0;
3621    hi = (hi + Math.imul(ah7, bh5)) | 0;
3622    lo = (lo + Math.imul(al6, bl6)) | 0;
3623    mid = (mid + Math.imul(al6, bh6)) | 0;
3624    mid = (mid + Math.imul(ah6, bl6)) | 0;
3625    hi = (hi + Math.imul(ah6, bh6)) | 0;
3626    lo = (lo + Math.imul(al5, bl7)) | 0;
3627    mid = (mid + Math.imul(al5, bh7)) | 0;
3628    mid = (mid + Math.imul(ah5, bl7)) | 0;
3629    hi = (hi + Math.imul(ah5, bh7)) | 0;
3630    lo = (lo + Math.imul(al4, bl8)) | 0;
3631    mid = (mid + Math.imul(al4, bh8)) | 0;
3632    mid = (mid + Math.imul(ah4, bl8)) | 0;
3633    hi = (hi + Math.imul(ah4, bh8)) | 0;
3634    lo = (lo + Math.imul(al3, bl9)) | 0;
3635    mid = (mid + Math.imul(al3, bh9)) | 0;
3636    mid = (mid + Math.imul(ah3, bl9)) | 0;
3637    hi = (hi + Math.imul(ah3, bh9)) | 0;
3638    var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3639    c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;
3640    w12 &= 0x3ffffff;
3641    /* k = 13 */
3642    lo = Math.imul(al9, bl4);
3643    mid = Math.imul(al9, bh4);
3644    mid = (mid + Math.imul(ah9, bl4)) | 0;
3645    hi = Math.imul(ah9, bh4);
3646    lo = (lo + Math.imul(al8, bl5)) | 0;
3647    mid = (mid + Math.imul(al8, bh5)) | 0;
3648    mid = (mid + Math.imul(ah8, bl5)) | 0;
3649    hi = (hi + Math.imul(ah8, bh5)) | 0;
3650    lo = (lo + Math.imul(al7, bl6)) | 0;
3651    mid = (mid + Math.imul(al7, bh6)) | 0;
3652    mid = (mid + Math.imul(ah7, bl6)) | 0;
3653    hi = (hi + Math.imul(ah7, bh6)) | 0;
3654    lo = (lo + Math.imul(al6, bl7)) | 0;
3655    mid = (mid + Math.imul(al6, bh7)) | 0;
3656    mid = (mid + Math.imul(ah6, bl7)) | 0;
3657    hi = (hi + Math.imul(ah6, bh7)) | 0;
3658    lo = (lo + Math.imul(al5, bl8)) | 0;
3659    mid = (mid + Math.imul(al5, bh8)) | 0;
3660    mid = (mid + Math.imul(ah5, bl8)) | 0;
3661    hi = (hi + Math.imul(ah5, bh8)) | 0;
3662    lo = (lo + Math.imul(al4, bl9)) | 0;
3663    mid = (mid + Math.imul(al4, bh9)) | 0;
3664    mid = (mid + Math.imul(ah4, bl9)) | 0;
3665    hi = (hi + Math.imul(ah4, bh9)) | 0;
3666    var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3667    c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;
3668    w13 &= 0x3ffffff;
3669    /* k = 14 */
3670    lo = Math.imul(al9, bl5);
3671    mid = Math.imul(al9, bh5);
3672    mid = (mid + Math.imul(ah9, bl5)) | 0;
3673    hi = Math.imul(ah9, bh5);
3674    lo = (lo + Math.imul(al8, bl6)) | 0;
3675    mid = (mid + Math.imul(al8, bh6)) | 0;
3676    mid = (mid + Math.imul(ah8, bl6)) | 0;
3677    hi = (hi + Math.imul(ah8, bh6)) | 0;
3678    lo = (lo + Math.imul(al7, bl7)) | 0;
3679    mid = (mid + Math.imul(al7, bh7)) | 0;
3680    mid = (mid + Math.imul(ah7, bl7)) | 0;
3681    hi = (hi + Math.imul(ah7, bh7)) | 0;
3682    lo = (lo + Math.imul(al6, bl8)) | 0;
3683    mid = (mid + Math.imul(al6, bh8)) | 0;
3684    mid = (mid + Math.imul(ah6, bl8)) | 0;
3685    hi = (hi + Math.imul(ah6, bh8)) | 0;
3686    lo = (lo + Math.imul(al5, bl9)) | 0;
3687    mid = (mid + Math.imul(al5, bh9)) | 0;
3688    mid = (mid + Math.imul(ah5, bl9)) | 0;
3689    hi = (hi + Math.imul(ah5, bh9)) | 0;
3690    var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3691    c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;
3692    w14 &= 0x3ffffff;
3693    /* k = 15 */
3694    lo = Math.imul(al9, bl6);
3695    mid = Math.imul(al9, bh6);
3696    mid = (mid + Math.imul(ah9, bl6)) | 0;
3697    hi = Math.imul(ah9, bh6);
3698    lo = (lo + Math.imul(al8, bl7)) | 0;
3699    mid = (mid + Math.imul(al8, bh7)) | 0;
3700    mid = (mid + Math.imul(ah8, bl7)) | 0;
3701    hi = (hi + Math.imul(ah8, bh7)) | 0;
3702    lo = (lo + Math.imul(al7, bl8)) | 0;
3703    mid = (mid + Math.imul(al7, bh8)) | 0;
3704    mid = (mid + Math.imul(ah7, bl8)) | 0;
3705    hi = (hi + Math.imul(ah7, bh8)) | 0;
3706    lo = (lo + Math.imul(al6, bl9)) | 0;
3707    mid = (mid + Math.imul(al6, bh9)) | 0;
3708    mid = (mid + Math.imul(ah6, bl9)) | 0;
3709    hi = (hi + Math.imul(ah6, bh9)) | 0;
3710    var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3711    c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;
3712    w15 &= 0x3ffffff;
3713    /* k = 16 */
3714    lo = Math.imul(al9, bl7);
3715    mid = Math.imul(al9, bh7);
3716    mid = (mid + Math.imul(ah9, bl7)) | 0;
3717    hi = Math.imul(ah9, bh7);
3718    lo = (lo + Math.imul(al8, bl8)) | 0;
3719    mid = (mid + Math.imul(al8, bh8)) | 0;
3720    mid = (mid + Math.imul(ah8, bl8)) | 0;
3721    hi = (hi + Math.imul(ah8, bh8)) | 0;
3722    lo = (lo + Math.imul(al7, bl9)) | 0;
3723    mid = (mid + Math.imul(al7, bh9)) | 0;
3724    mid = (mid + Math.imul(ah7, bl9)) | 0;
3725    hi = (hi + Math.imul(ah7, bh9)) | 0;
3726    var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3727    c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;
3728    w16 &= 0x3ffffff;
3729    /* k = 17 */
3730    lo = Math.imul(al9, bl8);
3731    mid = Math.imul(al9, bh8);
3732    mid = (mid + Math.imul(ah9, bl8)) | 0;
3733    hi = Math.imul(ah9, bh8);
3734    lo = (lo + Math.imul(al8, bl9)) | 0;
3735    mid = (mid + Math.imul(al8, bh9)) | 0;
3736    mid = (mid + Math.imul(ah8, bl9)) | 0;
3737    hi = (hi + Math.imul(ah8, bh9)) | 0;
3738    var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3739    c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;
3740    w17 &= 0x3ffffff;
3741    /* k = 18 */
3742    lo = Math.imul(al9, bl9);
3743    mid = Math.imul(al9, bh9);
3744    mid = (mid + Math.imul(ah9, bl9)) | 0;
3745    hi = Math.imul(ah9, bh9);
3746    var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;
3747    c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;
3748    w18 &= 0x3ffffff;
3749    o[0] = w0;
3750    o[1] = w1;
3751    o[2] = w2;
3752    o[3] = w3;
3753    o[4] = w4;
3754    o[5] = w5;
3755    o[6] = w6;
3756    o[7] = w7;
3757    o[8] = w8;
3758    o[9] = w9;
3759    o[10] = w10;
3760    o[11] = w11;
3761    o[12] = w12;
3762    o[13] = w13;
3763    o[14] = w14;
3764    o[15] = w15;
3765    o[16] = w16;
3766    o[17] = w17;
3767    o[18] = w18;
3768    if (c !== 0) {
3769      o[19] = c;
3770      out.length++;
3771    }
3772    return out;
3773  };
3774
3775  // Polyfill comb
3776  if (!Math.imul) {
3777    comb10MulTo = smallMulTo;
3778  }
3779
3780  function bigMulTo (self, num, out) {
3781    out.negative = num.negative ^ self.negative;
3782    out.length = self.length + num.length;
3783
3784    var carry = 0;
3785    var hncarry = 0;
3786    for (var k = 0; k < out.length - 1; k++) {
3787      // Sum all words with the same `i + j = k` and accumulate `ncarry`,
3788      // note that ncarry could be >= 0x3ffffff
3789      var ncarry = hncarry;
3790      hncarry = 0;
3791      var rword = carry & 0x3ffffff;
3792      var maxJ = Math.min(k, num.length - 1);
3793      for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
3794        var i = k - j;
3795        var a = self.words[i] | 0;
3796        var b = num.words[j] | 0;
3797        var r = a * b;
3798
3799        var lo = r & 0x3ffffff;
3800        ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;
3801        lo = (lo + rword) | 0;
3802        rword = lo & 0x3ffffff;
3803        ncarry = (ncarry + (lo >>> 26)) | 0;
3804
3805        hncarry += ncarry >>> 26;
3806        ncarry &= 0x3ffffff;
3807      }
3808      out.words[k] = rword;
3809      carry = ncarry;
3810      ncarry = hncarry;
3811    }
3812    if (carry !== 0) {
3813      out.words[k] = carry;
3814    } else {
3815      out.length--;
3816    }
3817
3818    return out.strip();
3819  }
3820
3821  function jumboMulTo (self, num, out) {
3822    var fftm = new FFTM();
3823    return fftm.mulp(self, num, out);
3824  }
3825
3826  BN.prototype.mulTo = function mulTo (num, out) {
3827    var res;
3828    var len = this.length + num.length;
3829    if (this.length === 10 && num.length === 10) {
3830      res = comb10MulTo(this, num, out);
3831    } else if (len < 63) {
3832      res = smallMulTo(this, num, out);
3833    } else if (len < 1024) {
3834      res = bigMulTo(this, num, out);
3835    } else {
3836      res = jumboMulTo(this, num, out);
3837    }
3838
3839    return res;
3840  };
3841
3842  // Cooley-Tukey algorithm for FFT
3843  // slightly revisited to rely on looping instead of recursion
3844
3845  function FFTM (x, y) {
3846    this.x = x;
3847    this.y = y;
3848  }
3849
3850  FFTM.prototype.makeRBT = function makeRBT (N) {
3851    var t = new Array(N);
3852    var l = BN.prototype._countBits(N) - 1;
3853    for (var i = 0; i < N; i++) {
3854      t[i] = this.revBin(i, l, N);
3855    }
3856
3857    return t;
3858  };
3859
3860  // Returns binary-reversed representation of `x`
3861  FFTM.prototype.revBin = function revBin (x, l, N) {
3862    if (x === 0 || x === N - 1) return x;
3863
3864    var rb = 0;
3865    for (var i = 0; i < l; i++) {
3866      rb |= (x & 1) << (l - i - 1);
3867      x >>= 1;
3868    }
3869
3870    return rb;
3871  };
3872
3873  // Performs "tweedling" phase, therefore 'emulating'
3874  // behaviour of the recursive algorithm
3875  FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {
3876    for (var i = 0; i < N; i++) {
3877      rtws[i] = rws[rbt[i]];
3878      itws[i] = iws[rbt[i]];
3879    }
3880  };
3881
3882  FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {
3883    this.permute(rbt, rws, iws, rtws, itws, N);
3884
3885    for (var s = 1; s < N; s <<= 1) {
3886      var l = s << 1;
3887
3888      var rtwdf = Math.cos(2 * Math.PI / l);
3889      var itwdf = Math.sin(2 * Math.PI / l);
3890
3891      for (var p = 0; p < N; p += l) {
3892        var rtwdf_ = rtwdf;
3893        var itwdf_ = itwdf;
3894
3895        for (var j = 0; j < s; j++) {
3896          var re = rtws[p + j];
3897          var ie = itws[p + j];
3898
3899          var ro = rtws[p + j + s];
3900          var io = itws[p + j + s];
3901
3902          var rx = rtwdf_ * ro - itwdf_ * io;
3903
3904          io = rtwdf_ * io + itwdf_ * ro;
3905          ro = rx;
3906
3907          rtws[p + j] = re + ro;
3908          itws[p + j] = ie + io;
3909
3910          rtws[p + j + s] = re - ro;
3911          itws[p + j + s] = ie - io;
3912
3913          /* jshint maxdepth : false */
3914          if (j !== l) {
3915            rx = rtwdf * rtwdf_ - itwdf * itwdf_;
3916
3917            itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
3918            rtwdf_ = rx;
3919          }
3920        }
3921      }
3922    }
3923  };
3924
3925  FFTM.prototype.guessLen13b = function guessLen13b (n, m) {
3926    var N = Math.max(m, n) | 1;
3927    var odd = N & 1;
3928    var i = 0;
3929    for (N = N / 2 | 0; N; N = N >>> 1) {
3930      i++;
3931    }
3932
3933    return 1 << i + 1 + odd;
3934  };
3935
3936  FFTM.prototype.conjugate = function conjugate (rws, iws, N) {
3937    if (N <= 1) return;
3938
3939    for (var i = 0; i < N / 2; i++) {
3940      var t = rws[i];
3941
3942      rws[i] = rws[N - i - 1];
3943      rws[N - i - 1] = t;
3944
3945      t = iws[i];
3946
3947      iws[i] = -iws[N - i - 1];
3948      iws[N - i - 1] = -t;
3949    }
3950  };
3951
3952  FFTM.prototype.normalize13b = function normalize13b (ws, N) {
3953    var carry = 0;
3954    for (var i = 0; i < N / 2; i++) {
3955      var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +
3956        Math.round(ws[2 * i] / N) +
3957        carry;
3958
3959      ws[i] = w & 0x3ffffff;
3960
3961      if (w < 0x4000000) {
3962        carry = 0;
3963      } else {
3964        carry = w / 0x4000000 | 0;
3965      }
3966    }
3967
3968    return ws;
3969  };
3970
3971  FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {
3972    var carry = 0;
3973    for (var i = 0; i < len; i++) {
3974      carry = carry + (ws[i] | 0);
3975
3976      rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;
3977      rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;
3978    }
3979
3980    // Pad with zeroes
3981    for (i = 2 * len; i < N; ++i) {
3982      rws[i] = 0;
3983    }
3984
3985    assert(carry === 0);
3986    assert((carry & ~0x1fff) === 0);
3987  };
3988
3989  FFTM.prototype.stub = function stub (N) {
3990    var ph = new Array(N);
3991    for (var i = 0; i < N; i++) {
3992      ph[i] = 0;
3993    }
3994
3995    return ph;
3996  };
3997
3998  FFTM.prototype.mulp = function mulp (x, y, out) {
3999    var N = 2 * this.guessLen13b(x.length, y.length);
4000
4001    var rbt = this.makeRBT(N);
4002
4003    var _ = this.stub(N);
4004
4005    var rws = new Array(N);
4006    var rwst = new Array(N);
4007    var iwst = new Array(N);
4008
4009    var nrws = new Array(N);
4010    var nrwst = new Array(N);
4011    var niwst = new Array(N);
4012
4013    var rmws = out.words;
4014    rmws.length = N;
4015
4016    this.convert13b(x.words, x.length, rws, N);
4017    this.convert13b(y.words, y.length, nrws, N);
4018
4019    this.transform(rws, _, rwst, iwst, N, rbt);
4020    this.transform(nrws, _, nrwst, niwst, N, rbt);
4021
4022    for (var i = 0; i < N; i++) {
4023      var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
4024      iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
4025      rwst[i] = rx;
4026    }
4027
4028    this.conjugate(rwst, iwst, N);
4029    this.transform(rwst, iwst, rmws, _, N, rbt);
4030    this.conjugate(rmws, _, N);
4031    this.normalize13b(rmws, N);
4032
4033    out.negative = x.negative ^ y.negative;
4034    out.length = x.length + y.length;
4035    return out.strip();
4036  };
4037
4038  // Multiply `this` by `num`
4039  BN.prototype.mul = function mul (num) {
4040    var out = new BN(null);
4041    out.words = new Array(this.length + num.length);
4042    return this.mulTo(num, out);
4043  };
4044
4045  // Multiply employing FFT
4046  BN.prototype.mulf = function mulf (num) {
4047    var out = new BN(null);
4048    out.words = new Array(this.length + num.length);
4049    return jumboMulTo(this, num, out);
4050  };
4051
4052  // In-place Multiplication
4053  BN.prototype.imul = function imul (num) {
4054    return this.clone().mulTo(num, this);
4055  };
4056
4057  BN.prototype.imuln = function imuln (num) {
4058    assert(typeof num === 'number');
4059    assert(num < 0x4000000);
4060
4061    // Carry
4062    var carry = 0;
4063    for (var i = 0; i < this.length; i++) {
4064      var w = (this.words[i] | 0) * num;
4065      var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);
4066      carry >>= 26;
4067      carry += (w / 0x4000000) | 0;
4068      // NOTE: lo is 27bit maximum
4069      carry += lo >>> 26;
4070      this.words[i] = lo & 0x3ffffff;
4071    }
4072
4073    if (carry !== 0) {
4074      this.words[i] = carry;
4075      this.length++;
4076    }
4077
4078    return this;
4079  };
4080
4081  BN.prototype.muln = function muln (num) {
4082    return this.clone().imuln(num);
4083  };
4084
4085  // `this` * `this`
4086  BN.prototype.sqr = function sqr () {
4087    return this.mul(this);
4088  };
4089
4090  // `this` * `this` in-place
4091  BN.prototype.isqr = function isqr () {
4092    return this.imul(this.clone());
4093  };
4094
4095  // Math.pow(`this`, `num`)
4096  BN.prototype.pow = function pow (num) {
4097    var w = toBitArray(num);
4098    if (w.length === 0) return new BN(1);
4099
4100    // Skip leading zeroes
4101    var res = this;
4102    for (var i = 0; i < w.length; i++, res = res.sqr()) {
4103      if (w[i] !== 0) break;
4104    }
4105
4106    if (++i < w.length) {
4107      for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
4108        if (w[i] === 0) continue;
4109
4110        res = res.mul(q);
4111      }
4112    }
4113
4114    return res;
4115  };
4116
4117  // Shift-left in-place
4118  BN.prototype.iushln = function iushln (bits) {
4119    assert(typeof bits === 'number' && bits >= 0);
4120    var r = bits % 26;
4121    var s = (bits - r) / 26;
4122    var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);
4123    var i;
4124
4125    if (r !== 0) {
4126      var carry = 0;
4127
4128      for (i = 0; i < this.length; i++) {
4129        var newCarry = this.words[i] & carryMask;
4130        var c = ((this.words[i] | 0) - newCarry) << r;
4131        this.words[i] = c | carry;
4132        carry = newCarry >>> (26 - r);
4133      }
4134
4135      if (carry) {
4136        this.words[i] = carry;
4137        this.length++;
4138      }
4139    }
4140
4141    if (s !== 0) {
4142      for (i = this.length - 1; i >= 0; i--) {
4143        this.words[i + s] = this.words[i];
4144      }
4145
4146      for (i = 0; i < s; i++) {
4147        this.words[i] = 0;
4148      }
4149
4150      this.length += s;
4151    }
4152
4153    return this.strip();
4154  };
4155
4156  BN.prototype.ishln = function ishln (bits) {
4157    // TODO(indutny): implement me
4158    assert(this.negative === 0);
4159    return this.iushln(bits);
4160  };
4161
4162  // Shift-right in-place
4163  // NOTE: `hint` is a lowest bit before trailing zeroes
4164  // NOTE: if `extended` is present - it will be filled with destroyed bits
4165  BN.prototype.iushrn = function iushrn (bits, hint, extended) {
4166    assert(typeof bits === 'number' && bits >= 0);
4167    var h;
4168    if (hint) {
4169      h = (hint - (hint % 26)) / 26;
4170    } else {
4171      h = 0;
4172    }
4173
4174    var r = bits % 26;
4175    var s = Math.min((bits - r) / 26, this.length);
4176    var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
4177    var maskedWords = extended;
4178
4179    h -= s;
4180    h = Math.max(0, h);
4181
4182    // Extended mode, copy masked part
4183    if (maskedWords) {
4184      for (var i = 0; i < s; i++) {
4185        maskedWords.words[i] = this.words[i];
4186      }
4187      maskedWords.length = s;
4188    }
4189
4190    if (s === 0) {
4191      // No-op, we should not move anything at all
4192    } else if (this.length > s) {
4193      this.length -= s;
4194      for (i = 0; i < this.length; i++) {
4195        this.words[i] = this.words[i + s];
4196      }
4197    } else {
4198      this.words[0] = 0;
4199      this.length = 1;
4200    }
4201
4202    var carry = 0;
4203    for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
4204      var word = this.words[i] | 0;
4205      this.words[i] = (carry << (26 - r)) | (word >>> r);
4206      carry = word & mask;
4207    }
4208
4209    // Push carried bits as a mask
4210    if (maskedWords && carry !== 0) {
4211      maskedWords.words[maskedWords.length++] = carry;
4212    }
4213
4214    if (this.length === 0) {
4215      this.words[0] = 0;
4216      this.length = 1;
4217    }
4218
4219    return this.strip();
4220  };
4221
4222  BN.prototype.ishrn = function ishrn (bits, hint, extended) {
4223    // TODO(indutny): implement me
4224    assert(this.negative === 0);
4225    return this.iushrn(bits, hint, extended);
4226  };
4227
4228  // Shift-left
4229  BN.prototype.shln = function shln (bits) {
4230    return this.clone().ishln(bits);
4231  };
4232
4233  BN.prototype.ushln = function ushln (bits) {
4234    return this.clone().iushln(bits);
4235  };
4236
4237  // Shift-right
4238  BN.prototype.shrn = function shrn (bits) {
4239    return this.clone().ishrn(bits);
4240  };
4241
4242  BN.prototype.ushrn = function ushrn (bits) {
4243    return this.clone().iushrn(bits);
4244  };
4245
4246  // Test if n bit is set
4247  BN.prototype.testn = function testn (bit) {
4248    assert(typeof bit === 'number' && bit >= 0);
4249    var r = bit % 26;
4250    var s = (bit - r) / 26;
4251    var q = 1 << r;
4252
4253    // Fast case: bit is much higher than all existing words
4254    if (this.length <= s) return false;
4255
4256    // Check bit and return
4257    var w = this.words[s];
4258
4259    return !!(w & q);
4260  };
4261
4262  // Return only lowers bits of number (in-place)
4263  BN.prototype.imaskn = function imaskn (bits) {
4264    assert(typeof bits === 'number' && bits >= 0);
4265    var r = bits % 26;
4266    var s = (bits - r) / 26;
4267
4268    assert(this.negative === 0, 'imaskn works only with positive numbers');
4269
4270    if (this.length <= s) {
4271      return this;
4272    }
4273
4274    if (r !== 0) {
4275      s++;
4276    }
4277    this.length = Math.min(s, this.length);
4278
4279    if (r !== 0) {
4280      var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);
4281      this.words[this.length - 1] &= mask;
4282    }
4283
4284    return this.strip();
4285  };
4286
4287  // Return only lowers bits of number
4288  BN.prototype.maskn = function maskn (bits) {
4289    return this.clone().imaskn(bits);
4290  };
4291
4292  // Add plain number `num` to `this`
4293  BN.prototype.iaddn = function iaddn (num) {
4294    assert(typeof num === 'number');
4295    assert(num < 0x4000000);
4296    if (num < 0) return this.isubn(-num);
4297
4298    // Possible sign change
4299    if (this.negative !== 0) {
4300      if (this.length === 1 && (this.words[0] | 0) < num) {
4301        this.words[0] = num - (this.words[0] | 0);
4302        this.negative = 0;
4303        return this;
4304      }
4305
4306      this.negative = 0;
4307      this.isubn(num);
4308      this.negative = 1;
4309      return this;
4310    }
4311
4312    // Add without checks
4313    return this._iaddn(num);
4314  };
4315
4316  BN.prototype._iaddn = function _iaddn (num) {
4317    this.words[0] += num;
4318
4319    // Carry
4320    for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {
4321      this.words[i] -= 0x4000000;
4322      if (i === this.length - 1) {
4323        this.words[i + 1] = 1;
4324      } else {
4325        this.words[i + 1]++;
4326      }
4327    }
4328    this.length = Math.max(this.length, i + 1);
4329
4330    return this;
4331  };
4332
4333  // Subtract plain number `num` from `this`
4334  BN.prototype.isubn = function isubn (num) {
4335    assert(typeof num === 'number');
4336    assert(num < 0x4000000);
4337    if (num < 0) return this.iaddn(-num);
4338
4339    if (this.negative !== 0) {
4340      this.negative = 0;
4341      this.iaddn(num);
4342      this.negative = 1;
4343      return this;
4344    }
4345
4346    this.words[0] -= num;
4347
4348    if (this.length === 1 && this.words[0] < 0) {
4349      this.words[0] = -this.words[0];
4350      this.negative = 1;
4351    } else {
4352      // Carry
4353      for (var i = 0; i < this.length && this.words[i] < 0; i++) {
4354        this.words[i] += 0x4000000;
4355        this.words[i + 1] -= 1;
4356      }
4357    }
4358
4359    return this.strip();
4360  };
4361
4362  BN.prototype.addn = function addn (num) {
4363    return this.clone().iaddn(num);
4364  };
4365
4366  BN.prototype.subn = function subn (num) {
4367    return this.clone().isubn(num);
4368  };
4369
4370  BN.prototype.iabs = function iabs () {
4371    this.negative = 0;
4372
4373    return this;
4374  };
4375
4376  BN.prototype.abs = function abs () {
4377    return this.clone().iabs();
4378  };
4379
4380  BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {
4381    var len = num.length + shift;
4382    var i;
4383
4384    this._expand(len);
4385
4386    var w;
4387    var carry = 0;
4388    for (i = 0; i < num.length; i++) {
4389      w = (this.words[i + shift] | 0) + carry;
4390      var right = (num.words[i] | 0) * mul;
4391      w -= right & 0x3ffffff;
4392      carry = (w >> 26) - ((right / 0x4000000) | 0);
4393      this.words[i + shift] = w & 0x3ffffff;
4394    }
4395    for (; i < this.length - shift; i++) {
4396      w = (this.words[i + shift] | 0) + carry;
4397      carry = w >> 26;
4398      this.words[i + shift] = w & 0x3ffffff;
4399    }
4400
4401    if (carry === 0) return this.strip();
4402
4403    // Subtraction overflow
4404    assert(carry === -1);
4405    carry = 0;
4406    for (i = 0; i < this.length; i++) {
4407      w = -(this.words[i] | 0) + carry;
4408      carry = w >> 26;
4409      this.words[i] = w & 0x3ffffff;
4410    }
4411    this.negative = 1;
4412
4413    return this.strip();
4414  };
4415
4416  BN.prototype._wordDiv = function _wordDiv (num, mode) {
4417    var shift = this.length - num.length;
4418
4419    var a = this.clone();
4420    var b = num;
4421
4422    // Normalize
4423    var bhi = b.words[b.length - 1] | 0;
4424    var bhiBits = this._countBits(bhi);
4425    shift = 26 - bhiBits;
4426    if (shift !== 0) {
4427      b = b.ushln(shift);
4428      a.iushln(shift);
4429      bhi = b.words[b.length - 1] | 0;
4430    }
4431
4432    // Initialize quotient
4433    var m = a.length - b.length;
4434    var q;
4435
4436    if (mode !== 'mod') {
4437      q = new BN(null);
4438      q.length = m + 1;
4439      q.words = new Array(q.length);
4440      for (var i = 0; i < q.length; i++) {
4441        q.words[i] = 0;
4442      }
4443    }
4444
4445    var diff = a.clone()._ishlnsubmul(b, 1, m);
4446    if (diff.negative === 0) {
4447      a = diff;
4448      if (q) {
4449        q.words[m] = 1;
4450      }
4451    }
4452
4453    for (var j = m - 1; j >= 0; j--) {
4454      var qj = (a.words[b.length + j] | 0) * 0x4000000 +
4455        (a.words[b.length + j - 1] | 0);
4456
4457      // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max
4458      // (0x7ffffff)
4459      qj = Math.min((qj / bhi) | 0, 0x3ffffff);
4460
4461      a._ishlnsubmul(b, qj, j);
4462      while (a.negative !== 0) {
4463        qj--;
4464        a.negative = 0;
4465        a._ishlnsubmul(b, 1, j);
4466        if (!a.isZero()) {
4467          a.negative ^= 1;
4468        }
4469      }
4470      if (q) {
4471        q.words[j] = qj;
4472      }
4473    }
4474    if (q) {
4475      q.strip();
4476    }
4477    a.strip();
4478
4479    // Denormalize
4480    if (mode !== 'div' && shift !== 0) {
4481      a.iushrn(shift);
4482    }
4483
4484    return {
4485      div: q || null,
4486      mod: a
4487    };
4488  };
4489
4490  // NOTE: 1) `mode` can be set to `mod` to request mod only,
4491  //       to `div` to request div only, or be absent to
4492  //       request both div & mod
4493  //       2) `positive` is true if unsigned mod is requested
4494  BN.prototype.divmod = function divmod (num, mode, positive) {
4495    assert(!num.isZero());
4496
4497    if (this.isZero()) {
4498      return {
4499        div: new BN(0),
4500        mod: new BN(0)
4501      };
4502    }
4503
4504    var div, mod, res;
4505    if (this.negative !== 0 && num.negative === 0) {
4506      res = this.neg().divmod(num, mode);
4507
4508      if (mode !== 'mod') {
4509        div = res.div.neg();
4510      }
4511
4512      if (mode !== 'div') {
4513        mod = res.mod.neg();
4514        if (positive && mod.negative !== 0) {
4515          mod.iadd(num);
4516        }
4517      }
4518
4519      return {
4520        div: div,
4521        mod: mod
4522      };
4523    }
4524
4525    if (this.negative === 0 && num.negative !== 0) {
4526      res = this.divmod(num.neg(), mode);
4527
4528      if (mode !== 'mod') {
4529        div = res.div.neg();
4530      }
4531
4532      return {
4533        div: div,
4534        mod: res.mod
4535      };
4536    }
4537
4538    if ((this.negative & num.negative) !== 0) {
4539      res = this.neg().divmod(num.neg(), mode);
4540
4541      if (mode !== 'div') {
4542        mod = res.mod.neg();
4543        if (positive && mod.negative !== 0) {
4544          mod.isub(num);
4545        }
4546      }
4547
4548      return {
4549        div: res.div,
4550        mod: mod
4551      };
4552    }
4553
4554    // Both numbers are positive at this point
4555
4556    // Strip both numbers to approximate shift value
4557    if (num.length > this.length || this.cmp(num) < 0) {
4558      return {
4559        div: new BN(0),
4560        mod: this
4561      };
4562    }
4563
4564    // Very short reduction
4565    if (num.length === 1) {
4566      if (mode === 'div') {
4567        return {
4568          div: this.divn(num.words[0]),
4569          mod: null
4570        };
4571      }
4572
4573      if (mode === 'mod') {
4574        return {
4575          div: null,
4576          mod: new BN(this.modn(num.words[0]))
4577        };
4578      }
4579
4580      return {
4581        div: this.divn(num.words[0]),
4582        mod: new BN(this.modn(num.words[0]))
4583      };
4584    }
4585
4586    return this._wordDiv(num, mode);
4587  };
4588
4589  // Find `this` / `num`
4590  BN.prototype.div = function div (num) {
4591    return this.divmod(num, 'div', false).div;
4592  };
4593
4594  // Find `this` % `num`
4595  BN.prototype.mod = function mod (num) {
4596    return this.divmod(num, 'mod', false).mod;
4597  };
4598
4599  BN.prototype.umod = function umod (num) {
4600    return this.divmod(num, 'mod', true).mod;
4601  };
4602
4603  // Find Round(`this` / `num`)
4604  BN.prototype.divRound = function divRound (num) {
4605    var dm = this.divmod(num);
4606
4607    // Fast case - exact division
4608    if (dm.mod.isZero()) return dm.div;
4609
4610    var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
4611
4612    var half = num.ushrn(1);
4613    var r2 = num.andln(1);
4614    var cmp = mod.cmp(half);
4615
4616    // Round down
4617    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
4618
4619    // Round up
4620    return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
4621  };
4622
4623  BN.prototype.modn = function modn (num) {
4624    assert(num <= 0x3ffffff);
4625    var p = (1 << 26) % num;
4626
4627    var acc = 0;
4628    for (var i = this.length - 1; i >= 0; i--) {
4629      acc = (p * acc + (this.words[i] | 0)) % num;
4630    }
4631
4632    return acc;
4633  };
4634
4635  // In-place division by number
4636  BN.prototype.idivn = function idivn (num) {
4637    assert(num <= 0x3ffffff);
4638
4639    var carry = 0;
4640    for (var i = this.length - 1; i >= 0; i--) {
4641      var w = (this.words[i] | 0) + carry * 0x4000000;
4642      this.words[i] = (w / num) | 0;
4643      carry = w % num;
4644    }
4645
4646    return this.strip();
4647  };
4648
4649  BN.prototype.divn = function divn (num) {
4650    return this.clone().idivn(num);
4651  };
4652
4653  BN.prototype.egcd = function egcd (p) {
4654    assert(p.negative === 0);
4655    assert(!p.isZero());
4656
4657    var x = this;
4658    var y = p.clone();
4659
4660    if (x.negative !== 0) {
4661      x = x.umod(p);
4662    } else {
4663      x = x.clone();
4664    }
4665
4666    // A * x + B * y = x
4667    var A = new BN(1);
4668    var B = new BN(0);
4669
4670    // C * x + D * y = y
4671    var C = new BN(0);
4672    var D = new BN(1);
4673
4674    var g = 0;
4675
4676    while (x.isEven() && y.isEven()) {
4677      x.iushrn(1);
4678      y.iushrn(1);
4679      ++g;
4680    }
4681
4682    var yp = y.clone();
4683    var xp = x.clone();
4684
4685    while (!x.isZero()) {
4686      for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
4687      if (i > 0) {
4688        x.iushrn(i);
4689        while (i-- > 0) {
4690          if (A.isOdd() || B.isOdd()) {
4691            A.iadd(yp);
4692            B.isub(xp);
4693          }
4694
4695          A.iushrn(1);
4696          B.iushrn(1);
4697        }
4698      }
4699
4700      for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
4701      if (j > 0) {
4702        y.iushrn(j);
4703        while (j-- > 0) {
4704          if (C.isOdd() || D.isOdd()) {
4705            C.iadd(yp);
4706            D.isub(xp);
4707          }
4708
4709          C.iushrn(1);
4710          D.iushrn(1);
4711        }
4712      }
4713
4714      if (x.cmp(y) >= 0) {
4715        x.isub(y);
4716        A.isub(C);
4717        B.isub(D);
4718      } else {
4719        y.isub(x);
4720        C.isub(A);
4721        D.isub(B);
4722      }
4723    }
4724
4725    return {
4726      a: C,
4727      b: D,
4728      gcd: y.iushln(g)
4729    };
4730  };
4731
4732  // This is reduced incarnation of the binary EEA
4733  // above, designated to invert members of the
4734  // _prime_ fields F(p) at a maximal speed
4735  BN.prototype._invmp = function _invmp (p) {
4736    assert(p.negative === 0);
4737    assert(!p.isZero());
4738
4739    var a = this;
4740    var b = p.clone();
4741
4742    if (a.negative !== 0) {
4743      a = a.umod(p);
4744    } else {
4745      a = a.clone();
4746    }
4747
4748    var x1 = new BN(1);
4749    var x2 = new BN(0);
4750
4751    var delta = b.clone();
4752
4753    while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
4754      for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
4755      if (i > 0) {
4756        a.iushrn(i);
4757        while (i-- > 0) {
4758          if (x1.isOdd()) {
4759            x1.iadd(delta);
4760          }
4761
4762          x1.iushrn(1);
4763        }
4764      }
4765
4766      for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
4767      if (j > 0) {
4768        b.iushrn(j);
4769        while (j-- > 0) {
4770          if (x2.isOdd()) {
4771            x2.iadd(delta);
4772          }
4773
4774          x2.iushrn(1);
4775        }
4776      }
4777
4778      if (a.cmp(b) >= 0) {
4779        a.isub(b);
4780        x1.isub(x2);
4781      } else {
4782        b.isub(a);
4783        x2.isub(x1);
4784      }
4785    }
4786
4787    var res;
4788    if (a.cmpn(1) === 0) {
4789      res = x1;
4790    } else {
4791      res = x2;
4792    }
4793
4794    if (res.cmpn(0) < 0) {
4795      res.iadd(p);
4796    }
4797
4798    return res;
4799  };
4800
4801  BN.prototype.gcd = function gcd (num) {
4802    if (this.isZero()) return num.abs();
4803    if (num.isZero()) return this.abs();
4804
4805    var a = this.clone();
4806    var b = num.clone();
4807    a.negative = 0;
4808    b.negative = 0;
4809
4810    // Remove common factor of two
4811    for (var shift = 0; a.isEven() && b.isEven(); shift++) {
4812      a.iushrn(1);
4813      b.iushrn(1);
4814    }
4815
4816    do {
4817      while (a.isEven()) {
4818        a.iushrn(1);
4819      }
4820      while (b.isEven()) {
4821        b.iushrn(1);
4822      }
4823
4824      var r = a.cmp(b);
4825      if (r < 0) {
4826        // Swap `a` and `b` to make `a` always bigger than `b`
4827        var t = a;
4828        a = b;
4829        b = t;
4830      } else if (r === 0 || b.cmpn(1) === 0) {
4831        break;
4832      }
4833
4834      a.isub(b);
4835    } while (true);
4836
4837    return b.iushln(shift);
4838  };
4839
4840  // Invert number in the field F(num)
4841  BN.prototype.invm = function invm (num) {
4842    return this.egcd(num).a.umod(num);
4843  };
4844
4845  BN.prototype.isEven = function isEven () {
4846    return (this.words[0] & 1) === 0;
4847  };
4848
4849  BN.prototype.isOdd = function isOdd () {
4850    return (this.words[0] & 1) === 1;
4851  };
4852
4853  // And first word and num
4854  BN.prototype.andln = function andln (num) {
4855    return this.words[0] & num;
4856  };
4857
4858  // Increment at the bit position in-line
4859  BN.prototype.bincn = function bincn (bit) {
4860    assert(typeof bit === 'number');
4861    var r = bit % 26;
4862    var s = (bit - r) / 26;
4863    var q = 1 << r;
4864
4865    // Fast case: bit is much higher than all existing words
4866    if (this.length <= s) {
4867      this._expand(s + 1);
4868      this.words[s] |= q;
4869      return this;
4870    }
4871
4872    // Add bit and propagate, if needed
4873    var carry = q;
4874    for (var i = s; carry !== 0 && i < this.length; i++) {
4875      var w = this.words[i] | 0;
4876      w += carry;
4877      carry = w >>> 26;
4878      w &= 0x3ffffff;
4879      this.words[i] = w;
4880    }
4881    if (carry !== 0) {
4882      this.words[i] = carry;
4883      this.length++;
4884    }
4885    return this;
4886  };
4887
4888  BN.prototype.isZero = function isZero () {
4889    return this.length === 1 && this.words[0] === 0;
4890  };
4891
4892  BN.prototype.cmpn = function cmpn (num) {
4893    var negative = num < 0;
4894
4895    if (this.negative !== 0 && !negative) return -1;
4896    if (this.negative === 0 && negative) return 1;
4897
4898    this.strip();
4899
4900    var res;
4901    if (this.length > 1) {
4902      res = 1;
4903    } else {
4904      if (negative) {
4905        num = -num;
4906      }
4907
4908      assert(num <= 0x3ffffff, 'Number is too big');
4909
4910      var w = this.words[0] | 0;
4911      res = w === num ? 0 : w < num ? -1 : 1;
4912    }
4913    if (this.negative !== 0) return -res | 0;
4914    return res;
4915  };
4916
4917  // Compare two numbers and return:
4918  // 1 - if `this` > `num`
4919  // 0 - if `this` == `num`
4920  // -1 - if `this` < `num`
4921  BN.prototype.cmp = function cmp (num) {
4922    if (this.negative !== 0 && num.negative === 0) return -1;
4923    if (this.negative === 0 && num.negative !== 0) return 1;
4924
4925    var res = this.ucmp(num);
4926    if (this.negative !== 0) return -res | 0;
4927    return res;
4928  };
4929
4930  // Unsigned comparison
4931  BN.prototype.ucmp = function ucmp (num) {
4932    // At this point both numbers have the same sign
4933    if (this.length > num.length) return 1;
4934    if (this.length < num.length) return -1;
4935
4936    var res = 0;
4937    for (var i = this.length - 1; i >= 0; i--) {
4938      var a = this.words[i] | 0;
4939      var b = num.words[i] | 0;
4940
4941      if (a === b) continue;
4942      if (a < b) {
4943        res = -1;
4944      } else if (a > b) {
4945        res = 1;
4946      }
4947      break;
4948    }
4949    return res;
4950  };
4951
4952  BN.prototype.gtn = function gtn (num) {
4953    return this.cmpn(num) === 1;
4954  };
4955
4956  BN.prototype.gt = function gt (num) {
4957    return this.cmp(num) === 1;
4958  };
4959
4960  BN.prototype.gten = function gten (num) {
4961    return this.cmpn(num) >= 0;
4962  };
4963
4964  BN.prototype.gte = function gte (num) {
4965    return this.cmp(num) >= 0;
4966  };
4967
4968  BN.prototype.ltn = function ltn (num) {
4969    return this.cmpn(num) === -1;
4970  };
4971
4972  BN.prototype.lt = function lt (num) {
4973    return this.cmp(num) === -1;
4974  };
4975
4976  BN.prototype.lten = function lten (num) {
4977    return this.cmpn(num) <= 0;
4978  };
4979
4980  BN.prototype.lte = function lte (num) {
4981    return this.cmp(num) <= 0;
4982  };
4983
4984  BN.prototype.eqn = function eqn (num) {
4985    return this.cmpn(num) === 0;
4986  };
4987
4988  BN.prototype.eq = function eq (num) {
4989    return this.cmp(num) === 0;
4990  };
4991
4992  //
4993  // A reduce context, could be using montgomery or something better, depending
4994  // on the `m` itself.
4995  //
4996  BN.red = function red (num) {
4997    return new Red(num);
4998  };
4999
5000  BN.prototype.toRed = function toRed (ctx) {
5001    assert(!this.red, 'Already a number in reduction context');
5002    assert(this.negative === 0, 'red works only with positives');
5003    return ctx.convertTo(this)._forceRed(ctx);
5004  };
5005
5006  BN.prototype.fromRed = function fromRed () {
5007    assert(this.red, 'fromRed works only with numbers in reduction context');
5008    return this.red.convertFrom(this);
5009  };
5010
5011  BN.prototype._forceRed = function _forceRed (ctx) {
5012    this.red = ctx;
5013    return this;
5014  };
5015
5016  BN.prototype.forceRed = function forceRed (ctx) {
5017    assert(!this.red, 'Already a number in reduction context');
5018    return this._forceRed(ctx);
5019  };
5020
5021  BN.prototype.redAdd = function redAdd (num) {
5022    assert(this.red, 'redAdd works only with red numbers');
5023    return this.red.add(this, num);
5024  };
5025
5026  BN.prototype.redIAdd = function redIAdd (num) {
5027    assert(this.red, 'redIAdd works only with red numbers');
5028    return this.red.iadd(this, num);
5029  };
5030
5031  BN.prototype.redSub = function redSub (num) {
5032    assert(this.red, 'redSub works only with red numbers');
5033    return this.red.sub(this, num);
5034  };
5035
5036  BN.prototype.redISub = function redISub (num) {
5037    assert(this.red, 'redISub works only with red numbers');
5038    return this.red.isub(this, num);
5039  };
5040
5041  BN.prototype.redShl = function redShl (num) {
5042    assert(this.red, 'redShl works only with red numbers');
5043    return this.red.shl(this, num);
5044  };
5045
5046  BN.prototype.redMul = function redMul (num) {
5047    assert(this.red, 'redMul works only with red numbers');
5048    this.red._verify2(this, num);
5049    return this.red.mul(this, num);
5050  };
5051
5052  BN.prototype.redIMul = function redIMul (num) {
5053    assert(this.red, 'redMul works only with red numbers');
5054    this.red._verify2(this, num);
5055    return this.red.imul(this, num);
5056  };
5057
5058  BN.prototype.redSqr = function redSqr () {
5059    assert(this.red, 'redSqr works only with red numbers');
5060    this.red._verify1(this);
5061    return this.red.sqr(this);
5062  };
5063
5064  BN.prototype.redISqr = function redISqr () {
5065    assert(this.red, 'redISqr works only with red numbers');
5066    this.red._verify1(this);
5067    return this.red.isqr(this);
5068  };
5069
5070  // Square root over p
5071  BN.prototype.redSqrt = function redSqrt () {
5072    assert(this.red, 'redSqrt works only with red numbers');
5073    this.red._verify1(this);
5074    return this.red.sqrt(this);
5075  };
5076