@capxul/cli 4.20.0-beta.1

package/dist/lib-DH_xJGSE.mjs

@@ -0,0 +1,3642 @@
+import { _ as __commonJSMin, n as require_lib$5, r as require_lib$6, t as require_lib$7, v as __require } from "./main.mjs";
+//#region ../../node_modules/.pnpm/bn.js@5.2.3/node_modules/bn.js/lib/bn.js
+var require_bn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(module$1, exports$1) {
+		"use strict";
+		function assert(val, msg) {
+			if (!val) throw new Error(msg || "Assertion failed");
+		}
+		function inherits(ctor, superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+		function BN(number, base, endian) {
+			if (BN.isBN(number)) return number;
+			this.negative = 0;
+			this.words = null;
+			this.length = 0;
+			this.red = null;
+			if (number !== null) {
+				if (base === "le" || base === "be") {
+					endian = base;
+					base = 10;
+				}
+				this._init(number || 0, base || 10, endian || "be");
+			}
+		}
+		if (typeof module$1 === "object") module$1.exports = BN;
+		else exports$1.BN = BN;
+		BN.BN = BN;
+		BN.wordSize = 26;
+		var Buffer;
+		try {
+			if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") Buffer = window.Buffer;
+			else Buffer = __require("buffer").Buffer;
+		} catch (e) {}
+		BN.isBN = function isBN(num) {
+			if (num instanceof BN) return true;
+			return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
+		};
+		BN.max = function max(left, right) {
+			if (left.cmp(right) > 0) return left;
+			return right;
+		};
+		BN.min = function min(left, right) {
+			if (left.cmp(right) < 0) return left;
+			return right;
+		};
+		BN.prototype._init = function init(number, base, endian) {
+			if (typeof number === "number") return this._initNumber(number, base, endian);
+			if (typeof number === "object") return this._initArray(number, base, endian);
+			if (base === "hex") base = 16;
+			assert(base === (base | 0) && base >= 2 && base <= 36);
+			number = number.toString().replace(/\s+/g, "");
+			var start = 0;
+			if (number[0] === "-") {
+				start++;
+				this.negative = 1;
+			}
+			if (start < number.length) {
+				if (base === 16) this._parseHex(number, start, endian);
+				else {
+					this._parseBase(number, base, start);
+					if (endian === "le") this._initArray(this.toArray(), base, endian);
+				}
+			}
+		};
+		BN.prototype._initNumber = function _initNumber(number, base, endian) {
+			if (number < 0) {
+				this.negative = 1;
+				number = -number;
+			}
+			if (number < 67108864) {
+				this.words = [number & 67108863];
+				this.length = 1;
+			} else if (number < 4503599627370496) {
+				this.words = [number & 67108863, number / 67108864 & 67108863];
+				this.length = 2;
+			} else {
+				assert(number < 9007199254740992);
+				this.words = [
+					number & 67108863,
+					number / 67108864 & 67108863,
+					1
+				];
+				this.length = 3;
+			}
+			if (endian !== "le") return;
+			this._initArray(this.toArray(), base, endian);
+		};
+		BN.prototype._initArray = function _initArray(number, base, endian) {
+			assert(typeof number.length === "number");
+			if (number.length <= 0) {
+				this.words = [0];
+				this.length = 1;
+				return this;
+			}
+			this.length = Math.ceil(number.length / 3);
+			this.words = new Array(this.length);
+			for (var i = 0; i < this.length; i++) this.words[i] = 0;
+			var j, w;
+			var off = 0;
+			if (endian === "be") for (i = number.length - 1, j = 0; i >= 0; i -= 3) {
+				w = number[i] | number[i - 1] << 8 | number[i - 2] << 16;
+				this.words[j] |= w << off & 67108863;
+				this.words[j + 1] = w >>> 26 - off & 67108863;
+				off += 24;
+				if (off >= 26) {
+					off -= 26;
+					j++;
+				}
+			}
+			else if (endian === "le") for (i = 0, j = 0; i < number.length; i += 3) {
+				w = number[i] | number[i + 1] << 8 | number[i + 2] << 16;
+				this.words[j] |= w << off & 67108863;
+				this.words[j + 1] = w >>> 26 - off & 67108863;
+				off += 24;
+				if (off >= 26) {
+					off -= 26;
+					j++;
+				}
+			}
+			return this._strip();
+		};
+		function parseHex4Bits(string, index) {
+			var c = string.charCodeAt(index);
+			if (c >= 48 && c <= 57) return c - 48;
+			else if (c >= 65 && c <= 70) return c - 55;
+			else if (c >= 97 && c <= 102) return c - 87;
+			else assert(false, "Invalid character in " + string);
+		}
+		function parseHexByte(string, lowerBound, index) {
+			var r = parseHex4Bits(string, index);
+			if (index - 1 >= lowerBound) r |= parseHex4Bits(string, index - 1) << 4;
+			return r;
+		}
+		BN.prototype._parseHex = function _parseHex(number, start, endian) {
+			this.length = Math.ceil((number.length - start) / 6);
+			this.words = new Array(this.length);
+			for (var i = 0; i < this.length; i++) this.words[i] = 0;
+			var off = 0;
+			var j = 0;
+			var w;
+			if (endian === "be") for (i = number.length - 1; i >= start; i -= 2) {
+				w = parseHexByte(number, start, i) << off;
+				this.words[j] |= w & 67108863;
+				if (off >= 18) {
+					off -= 18;
+					j += 1;
+					this.words[j] |= w >>> 26;
+				} else off += 8;
+			}
+			else for (i = (number.length - start) % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {
+				w = parseHexByte(number, start, i) << off;
+				this.words[j] |= w & 67108863;
+				if (off >= 18) {
+					off -= 18;
+					j += 1;
+					this.words[j] |= w >>> 26;
+				} else off += 8;
+			}
+			this._strip();
+		};
+		function parseBase(str, start, end, mul) {
+			var r = 0;
+			var b = 0;
+			var len = Math.min(str.length, end);
+			for (var i = start; i < len; i++) {
+				var c = str.charCodeAt(i) - 48;
+				r *= mul;
+				if (c >= 49) b = c - 49 + 10;
+				else if (c >= 17) b = c - 17 + 10;
+				else b = c;
+				assert(c >= 0 && b < mul, "Invalid character");
+				r += b;
+			}
+			return r;
+		}
+		BN.prototype._parseBase = function _parseBase(number, base, start) {
+			this.words = [0];
+			this.length = 1;
+			for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base) limbLen++;
+			limbLen--;
+			limbPow = limbPow / base | 0;
+			var total = number.length - start;
+			var mod = total % limbLen;
+			var end = Math.min(total, total - mod) + start;
+			var word = 0;
+			for (var i = start; i < end; i += limbLen) {
+				word = parseBase(number, i, i + limbLen, base);
+				this.imuln(limbPow);
+				if (this.words[0] + word < 67108864) this.words[0] += word;
+				else this._iaddn(word);
+			}
+			if (mod !== 0) {
+				var pow = 1;
+				word = parseBase(number, i, number.length, base);
+				for (i = 0; i < mod; i++) pow *= base;
+				this.imuln(pow);
+				if (this.words[0] + word < 67108864) this.words[0] += word;
+				else this._iaddn(word);
+			}
+			this._strip();
+		};
+		BN.prototype.copy = function copy(dest) {
+			dest.words = new Array(this.length);
+			for (var i = 0; i < this.length; i++) dest.words[i] = this.words[i];
+			dest.length = this.length;
+			dest.negative = this.negative;
+			dest.red = this.red;
+		};
+		function move(dest, src) {
+			dest.words = src.words;
+			dest.length = src.length;
+			dest.negative = src.negative;
+			dest.red = src.red;
+		}
+		BN.prototype._move = function _move(dest) {
+			move(dest, this);
+		};
+		BN.prototype.clone = function clone() {
+			var r = new BN(null);
+			this.copy(r);
+			return r;
+		};
+		BN.prototype._expand = function _expand(size) {
+			while (this.length < size) this.words[this.length++] = 0;
+			return this;
+		};
+		BN.prototype._strip = function strip() {
+			while (this.length > 1 && this.words[this.length - 1] === 0) this.length--;
+			return this._normSign();
+		};
+		BN.prototype._normSign = function _normSign() {
+			if (this.length === 1 && this.words[0] === 0) this.negative = 0;
+			return this;
+		};
+		if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") try {
+			BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
+		} catch (e) {
+			BN.prototype.inspect = inspect;
+		}
+		else BN.prototype.inspect = inspect;
+		function inspect() {
+			return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
+		}
+		var zeros = [
+			"",
+			"0",
+			"00",
+			"000",
+			"0000",
+			"00000",
+			"000000",
+			"0000000",
+			"00000000",
+			"000000000",
+			"0000000000",
+			"00000000000",
+			"000000000000",
+			"0000000000000",
+			"00000000000000",
+			"000000000000000",
+			"0000000000000000",
+			"00000000000000000",
+			"000000000000000000",
+			"0000000000000000000",
+			"00000000000000000000",
+			"000000000000000000000",
+			"0000000000000000000000",
+			"00000000000000000000000",
+			"000000000000000000000000",
+			"0000000000000000000000000"
+		];
+		var groupSizes = [
+			0,
+			0,
+			25,
+			16,
+			12,
+			11,
+			10,
+			9,
+			8,
+			8,
+			7,
+			7,
+			7,
+			7,
+			6,
+			6,
+			6,
+			6,
+			6,
+			6,
+			6,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5,
+			5
+		];
+		var groupBases = [
+			0,
+			0,
+			33554432,
+			43046721,
+			16777216,
+			48828125,
+			60466176,
+			40353607,
+			16777216,
+			43046721,
+			1e7,
+			19487171,
+			35831808,
+			62748517,
+			7529536,
+			11390625,
+			16777216,
+			24137569,
+			34012224,
+			47045881,
+			64e6,
+			4084101,
+			5153632,
+			6436343,
+			7962624,
+			9765625,
+			11881376,
+			14348907,
+			17210368,
+			20511149,
+			243e5,
+			28629151,
+			33554432,
+			39135393,
+			45435424,
+			52521875,
+			60466176
+		];
+		BN.prototype.toString = function toString(base, padding) {
+			base = base || 10;
+			padding = padding | 0 || 1;
+			var out;
+			if (base === 16 || base === "hex") {
+				out = "";
+				var off = 0;
+				var carry = 0;
+				for (var i = 0; i < this.length; i++) {
+					var w = this.words[i];
+					var word = ((w << off | carry) & 16777215).toString(16);
+					carry = w >>> 24 - off & 16777215;
+					off += 2;
+					if (off >= 26) {
+						off -= 26;
+						i--;
+					}
+					if (carry !== 0 || i !== this.length - 1) out = zeros[6 - word.length] + word + out;
+					else out = word + out;
+				}
+				if (carry !== 0) out = carry.toString(16) + out;
+				while (out.length % padding !== 0) out = "0" + out;
+				if (this.negative !== 0) out = "-" + out;
+				return out;
+			}
+			if (base === (base | 0) && base >= 2 && base <= 36) {
+				var groupSize = groupSizes[base];
+				var groupBase = groupBases[base];
+				out = "";
+				var c = this.clone();
+				c.negative = 0;
+				while (!c.isZero()) {
+					var r = c.modrn(groupBase).toString(base);
+					c = c.idivn(groupBase);
+					if (!c.isZero()) out = zeros[groupSize - r.length] + r + out;
+					else out = r + out;
+				}
+				if (this.isZero()) out = "0" + out;
+				while (out.length % padding !== 0) out = "0" + out;
+				if (this.negative !== 0) out = "-" + out;
+				return out;
+			}
+			assert(false, "Base should be between 2 and 36");
+		};
+		BN.prototype.toNumber = function toNumber() {
+			var ret = this.words[0];
+			if (this.length === 2) ret += this.words[1] * 67108864;
+			else if (this.length === 3 && this.words[2] === 1) ret += 4503599627370496 + this.words[1] * 67108864;
+			else if (this.length > 2) assert(false, "Number can only safely store up to 53 bits");
+			return this.negative !== 0 ? -ret : ret;
+		};
+		BN.prototype.toJSON = function toJSON() {
+			return this.toString(16, 2);
+		};
+		if (Buffer) BN.prototype.toBuffer = function toBuffer(endian, length) {
+			return this.toArrayLike(Buffer, endian, length);
+		};
+		BN.prototype.toArray = function toArray(endian, length) {
+			return this.toArrayLike(Array, endian, length);
+		};
+		var allocate = function allocate(ArrayType, size) {
+			if (ArrayType.allocUnsafe) return ArrayType.allocUnsafe(size);
+			return new ArrayType(size);
+		};
+		BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
+			this._strip();
+			var byteLength = this.byteLength();
+			var reqLength = length || Math.max(1, byteLength);
+			assert(byteLength <= reqLength, "byte array longer than desired length");
+			assert(reqLength > 0, "Requested array length <= 0");
+			var res = allocate(ArrayType, reqLength);
+			var postfix = endian === "le" ? "LE" : "BE";
+			this["_toArrayLike" + postfix](res, byteLength);
+			return res;
+		};
+		BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength) {
+			var position = 0;
+			var carry = 0;
+			for (var i = 0, shift = 0; i < this.length; i++) {
+				var word = this.words[i] << shift | carry;
+				res[position++] = word & 255;
+				if (position < res.length) res[position++] = word >> 8 & 255;
+				if (position < res.length) res[position++] = word >> 16 & 255;
+				if (shift === 6) {
+					if (position < res.length) res[position++] = word >> 24 & 255;
+					carry = 0;
+					shift = 0;
+				} else {
+					carry = word >>> 24;
+					shift += 2;
+				}
+			}
+			if (position < res.length) {
+				res[position++] = carry;
+				while (position < res.length) res[position++] = 0;
+			}
+		};
+		BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength) {
+			var position = res.length - 1;
+			var carry = 0;
+			for (var i = 0, shift = 0; i < this.length; i++) {
+				var word = this.words[i] << shift | carry;
+				res[position--] = word & 255;
+				if (position >= 0) res[position--] = word >> 8 & 255;
+				if (position >= 0) res[position--] = word >> 16 & 255;
+				if (shift === 6) {
+					if (position >= 0) res[position--] = word >> 24 & 255;
+					carry = 0;
+					shift = 0;
+				} else {
+					carry = word >>> 24;
+					shift += 2;
+				}
+			}
+			if (position >= 0) {
+				res[position--] = carry;
+				while (position >= 0) res[position--] = 0;
+			}
+		};
+		if (Math.clz32) BN.prototype._countBits = function _countBits(w) {
+			return 32 - Math.clz32(w);
+		};
+		else BN.prototype._countBits = function _countBits(w) {
+			var t = w;
+			var r = 0;
+			if (t >= 4096) {
+				r += 13;
+				t >>>= 13;
+			}
+			if (t >= 64) {
+				r += 7;
+				t >>>= 7;
+			}
+			if (t >= 8) {
+				r += 4;
+				t >>>= 4;
+			}
+			if (t >= 2) {
+				r += 2;
+				t >>>= 2;
+			}
+			return r + t;
+		};
+		BN.prototype._zeroBits = function _zeroBits(w) {
+			if (w === 0) return 26;
+			var t = w;
+			var r = 0;
+			if ((t & 8191) === 0) {
+				r += 13;
+				t >>>= 13;
+			}
+			if ((t & 127) === 0) {
+				r += 7;
+				t >>>= 7;
+			}
+			if ((t & 15) === 0) {
+				r += 4;
+				t >>>= 4;
+			}
+			if ((t & 3) === 0) {
+				r += 2;
+				t >>>= 2;
+			}
+			if ((t & 1) === 0) r++;
+			return r;
+		};
+		BN.prototype.bitLength = function bitLength() {
+			var w = this.words[this.length - 1];
+			var hi = this._countBits(w);
+			return (this.length - 1) * 26 + hi;
+		};
+		function toBitArray(num) {
+			var w = new Array(num.bitLength());
+			for (var bit = 0; bit < w.length; bit++) {
+				var off = bit / 26 | 0;
+				var wbit = bit % 26;
+				w[bit] = num.words[off] >>> wbit & 1;
+			}
+			return w;
+		}
+		BN.prototype.zeroBits = function zeroBits() {
+			if (this.isZero()) return 0;
+			var r = 0;
+			for (var i = 0; i < this.length; i++) {
+				var b = this._zeroBits(this.words[i]);
+				r += b;
+				if (b !== 26) break;
+			}
+			return r;
+		};
+		BN.prototype.byteLength = function byteLength() {
+			return Math.ceil(this.bitLength() / 8);
+		};
+		BN.prototype.toTwos = function toTwos(width) {
+			if (this.negative !== 0) return this.abs().inotn(width).iaddn(1);
+			return this.clone();
+		};
+		BN.prototype.fromTwos = function fromTwos(width) {
+			if (this.testn(width - 1)) return this.notn(width).iaddn(1).ineg();
+			return this.clone();
+		};
+		BN.prototype.isNeg = function isNeg() {
+			return this.negative !== 0;
+		};
+		BN.prototype.neg = function neg() {
+			return this.clone().ineg();
+		};
+		BN.prototype.ineg = function ineg() {
+			if (!this.isZero()) this.negative ^= 1;
+			return this;
+		};
+		BN.prototype.iuor = function iuor(num) {
+			while (this.length < num.length) this.words[this.length++] = 0;
+			for (var i = 0; i < num.length; i++) this.words[i] = this.words[i] | num.words[i];
+			return this._strip();
+		};
+		BN.prototype.ior = function ior(num) {
+			assert((this.negative | num.negative) === 0);
+			return this.iuor(num);
+		};
+		BN.prototype.or = function or(num) {
+			if (this.length > num.length) return this.clone().ior(num);
+			return num.clone().ior(this);
+		};
+		BN.prototype.uor = function uor(num) {
+			if (this.length > num.length) return this.clone().iuor(num);
+			return num.clone().iuor(this);
+		};
+		BN.prototype.iuand = function iuand(num) {
+			var b;
+			if (this.length > num.length) b = num;
+			else b = this;
+			for (var i = 0; i < b.length; i++) this.words[i] = this.words[i] & num.words[i];
+			this.length = b.length;
+			return this._strip();
+		};
+		BN.prototype.iand = function iand(num) {
+			assert((this.negative | num.negative) === 0);
+			return this.iuand(num);
+		};
+		BN.prototype.and = function and(num) {
+			if (this.length > num.length) return this.clone().iand(num);
+			return num.clone().iand(this);
+		};
+		BN.prototype.uand = function uand(num) {
+			if (this.length > num.length) return this.clone().iuand(num);
+			return num.clone().iuand(this);
+		};
+		BN.prototype.iuxor = function iuxor(num) {
+			var a;
+			var b;
+			if (this.length > num.length) {
+				a = this;
+				b = num;
+			} else {
+				a = num;
+				b = this;
+			}
+			for (var i = 0; i < b.length; i++) this.words[i] = a.words[i] ^ b.words[i];
+			if (this !== a) for (; i < a.length; i++) this.words[i] = a.words[i];
+			this.length = a.length;
+			return this._strip();
+		};
+		BN.prototype.ixor = function ixor(num) {
+			assert((this.negative | num.negative) === 0);
+			return this.iuxor(num);
+		};
+		BN.prototype.xor = function xor(num) {
+			if (this.length > num.length) return this.clone().ixor(num);
+			return num.clone().ixor(this);
+		};
+		BN.prototype.uxor = function uxor(num) {
+			if (this.length > num.length) return this.clone().iuxor(num);
+			return num.clone().iuxor(this);
+		};
+		BN.prototype.inotn = function inotn(width) {
+			assert(typeof width === "number" && width >= 0);
+			var bytesNeeded = Math.ceil(width / 26) | 0;
+			var bitsLeft = width % 26;
+			this._expand(bytesNeeded);
+			if (bitsLeft > 0) bytesNeeded--;
+			for (var i = 0; i < bytesNeeded; i++) this.words[i] = ~this.words[i] & 67108863;
+			if (bitsLeft > 0) this.words[i] = ~this.words[i] & 67108863 >> 26 - bitsLeft;
+			return this._strip();
+		};
+		BN.prototype.notn = function notn(width) {
+			return this.clone().inotn(width);
+		};
+		BN.prototype.setn = function setn(bit, val) {
+			assert(typeof bit === "number" && bit >= 0);
+			var off = bit / 26 | 0;
+			var wbit = bit % 26;
+			this._expand(off + 1);
+			if (val) this.words[off] = this.words[off] | 1 << wbit;
+			else this.words[off] = this.words[off] & ~(1 << wbit);
+			return this._strip();
+		};
+		BN.prototype.iadd = function iadd(num) {
+			var r;
+			if (this.negative !== 0 && num.negative === 0) {
+				this.negative = 0;
+				r = this.isub(num);
+				this.negative ^= 1;
+				return this._normSign();
+			} else if (this.negative === 0 && num.negative !== 0) {
+				num.negative = 0;
+				r = this.isub(num);
+				num.negative = 1;
+				return r._normSign();
+			}
+			var a, b;
+			if (this.length > num.length) {
+				a = this;
+				b = num;
+			} else {
+				a = num;
+				b = this;
+			}
+			var carry = 0;
+			for (var i = 0; i < b.length; i++) {
+				r = (a.words[i] | 0) + (b.words[i] | 0) + carry;
+				this.words[i] = r & 67108863;
+				carry = r >>> 26;
+			}
+			for (; carry !== 0 && i < a.length; i++) {
+				r = (a.words[i] | 0) + carry;
+				this.words[i] = r & 67108863;
+				carry = r >>> 26;
+			}
+			this.length = a.length;
+			if (carry !== 0) {
+				this.words[this.length] = carry;
+				this.length++;
+			} else if (a !== this) for (; i < a.length; i++) this.words[i] = a.words[i];
+			return this;
+		};
+		BN.prototype.add = function add(num) {
+			var res;
+			if (num.negative !== 0 && this.negative === 0) {
+				num.negative = 0;
+				res = this.sub(num);
+				num.negative ^= 1;
+				return res;
+			} else if (num.negative === 0 && this.negative !== 0) {
+				this.negative = 0;
+				res = num.sub(this);
+				this.negative = 1;
+				return res;
+			}
+			if (this.length > num.length) return this.clone().iadd(num);
+			return num.clone().iadd(this);
+		};
+		BN.prototype.isub = function isub(num) {
+			if (num.negative !== 0) {
+				num.negative = 0;
+				var r = this.iadd(num);
+				num.negative = 1;
+				return r._normSign();
+			} else if (this.negative !== 0) {
+				this.negative = 0;
+				this.iadd(num);
+				this.negative = 1;
+				return this._normSign();
+			}
+			var cmp = this.cmp(num);
+			if (cmp === 0) {
+				this.negative = 0;
+				this.length = 1;
+				this.words[0] = 0;
+				return this;
+			}
+			var a, b;
+			if (cmp > 0) {
+				a = this;
+				b = num;
+			} else {
+				a = num;
+				b = this;
+			}
+			var carry = 0;
+			for (var i = 0; i < b.length; i++) {
+				r = (a.words[i] | 0) - (b.words[i] | 0) + carry;
+				carry = r >> 26;
+				this.words[i] = r & 67108863;
+			}
+			for (; carry !== 0 && i < a.length; i++) {
+				r = (a.words[i] | 0) + carry;
+				carry = r >> 26;
+				this.words[i] = r & 67108863;
+			}
+			if (carry === 0 && i < a.length && a !== this) for (; i < a.length; i++) this.words[i] = a.words[i];
+			this.length = Math.max(this.length, i);
+			if (a !== this) this.negative = 1;
+			return this._strip();
+		};
+		BN.prototype.sub = function sub(num) {
+			return this.clone().isub(num);
+		};
+		function smallMulTo(self, num, out) {
+			out.negative = num.negative ^ self.negative;
+			var len = self.length + num.length | 0;
+			out.length = len;
+			len = len - 1 | 0;
+			var a = self.words[0] | 0;
+			var b = num.words[0] | 0;
+			var r = a * b;
+			var lo = r & 67108863;
+			var carry = r / 67108864 | 0;
+			out.words[0] = lo;
+			for (var k = 1; k < len; k++) {
+				var ncarry = carry >>> 26;
+				var rword = carry & 67108863;
+				var maxJ = Math.min(k, num.length - 1);
+				for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+					var i = k - j | 0;
+					a = self.words[i] | 0;
+					b = num.words[j] | 0;
+					r = a * b + rword;
+					ncarry += r / 67108864 | 0;
+					rword = r & 67108863;
+				}
+				out.words[k] = rword | 0;
+				carry = ncarry | 0;
+			}
+			if (carry !== 0) out.words[k] = carry | 0;
+			else out.length--;
+			return out._strip();
+		}
+		var comb10MulTo = function comb10MulTo(self, num, out) {
+			var a = self.words;
+			var b = num.words;
+			var o = out.words;
+			var c = 0;
+			var lo;
+			var mid;
+			var hi;
+			var a0 = a[0] | 0;
+			var al0 = a0 & 8191;
+			var ah0 = a0 >>> 13;
+			var a1 = a[1] | 0;
+			var al1 = a1 & 8191;
+			var ah1 = a1 >>> 13;
+			var a2 = a[2] | 0;
+			var al2 = a2 & 8191;
+			var ah2 = a2 >>> 13;
+			var a3 = a[3] | 0;
+			var al3 = a3 & 8191;
+			var ah3 = a3 >>> 13;
+			var a4 = a[4] | 0;
+			var al4 = a4 & 8191;
+			var ah4 = a4 >>> 13;
+			var a5 = a[5] | 0;
+			var al5 = a5 & 8191;
+			var ah5 = a5 >>> 13;
+			var a6 = a[6] | 0;
+			var al6 = a6 & 8191;
+			var ah6 = a6 >>> 13;
+			var a7 = a[7] | 0;
+			var al7 = a7 & 8191;
+			var ah7 = a7 >>> 13;
+			var a8 = a[8] | 0;
+			var al8 = a8 & 8191;
+			var ah8 = a8 >>> 13;
+			var a9 = a[9] | 0;
+			var al9 = a9 & 8191;
+			var ah9 = a9 >>> 13;
+			var b0 = b[0] | 0;
+			var bl0 = b0 & 8191;
+			var bh0 = b0 >>> 13;
+			var b1 = b[1] | 0;
+			var bl1 = b1 & 8191;
+			var bh1 = b1 >>> 13;
+			var b2 = b[2] | 0;
+			var bl2 = b2 & 8191;
+			var bh2 = b2 >>> 13;
+			var b3 = b[3] | 0;
+			var bl3 = b3 & 8191;
+			var bh3 = b3 >>> 13;
+			var b4 = b[4] | 0;
+			var bl4 = b4 & 8191;
+			var bh4 = b4 >>> 13;
+			var b5 = b[5] | 0;
+			var bl5 = b5 & 8191;
+			var bh5 = b5 >>> 13;
+			var b6 = b[6] | 0;
+			var bl6 = b6 & 8191;
+			var bh6 = b6 >>> 13;
+			var b7 = b[7] | 0;
+			var bl7 = b7 & 8191;
+			var bh7 = b7 >>> 13;
+			var b8 = b[8] | 0;
+			var bl8 = b8 & 8191;
+			var bh8 = b8 >>> 13;
+			var b9 = b[9] | 0;
+			var bl9 = b9 & 8191;
+			var bh9 = b9 >>> 13;
+			out.negative = self.negative ^ num.negative;
+			out.length = 19;
+			lo = Math.imul(al0, bl0);
+			mid = Math.imul(al0, bh0);
+			mid = mid + Math.imul(ah0, bl0) | 0;
+			hi = Math.imul(ah0, bh0);
+			var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
+			w0 &= 67108863;
+			lo = Math.imul(al1, bl0);
+			mid = Math.imul(al1, bh0);
+			mid = mid + Math.imul(ah1, bl0) | 0;
+			hi = Math.imul(ah1, bh0);
+			lo = lo + Math.imul(al0, bl1) | 0;
+			mid = mid + Math.imul(al0, bh1) | 0;
+			mid = mid + Math.imul(ah0, bl1) | 0;
+			hi = hi + Math.imul(ah0, bh1) | 0;
+			var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
+			w1 &= 67108863;
+			lo = Math.imul(al2, bl0);
+			mid = Math.imul(al2, bh0);
+			mid = mid + Math.imul(ah2, bl0) | 0;
+			hi = Math.imul(ah2, bh0);
+			lo = lo + Math.imul(al1, bl1) | 0;
+			mid = mid + Math.imul(al1, bh1) | 0;
+			mid = mid + Math.imul(ah1, bl1) | 0;
+			hi = hi + Math.imul(ah1, bh1) | 0;
+			lo = lo + Math.imul(al0, bl2) | 0;
+			mid = mid + Math.imul(al0, bh2) | 0;
+			mid = mid + Math.imul(ah0, bl2) | 0;
+			hi = hi + Math.imul(ah0, bh2) | 0;
+			var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
+			w2 &= 67108863;
+			lo = Math.imul(al3, bl0);
+			mid = Math.imul(al3, bh0);
+			mid = mid + Math.imul(ah3, bl0) | 0;
+			hi = Math.imul(ah3, bh0);
+			lo = lo + Math.imul(al2, bl1) | 0;
+			mid = mid + Math.imul(al2, bh1) | 0;
+			mid = mid + Math.imul(ah2, bl1) | 0;
+			hi = hi + Math.imul(ah2, bh1) | 0;
+			lo = lo + Math.imul(al1, bl2) | 0;
+			mid = mid + Math.imul(al1, bh2) | 0;
+			mid = mid + Math.imul(ah1, bl2) | 0;
+			hi = hi + Math.imul(ah1, bh2) | 0;
+			lo = lo + Math.imul(al0, bl3) | 0;
+			mid = mid + Math.imul(al0, bh3) | 0;
+			mid = mid + Math.imul(ah0, bl3) | 0;
+			hi = hi + Math.imul(ah0, bh3) | 0;
+			var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
+			w3 &= 67108863;
+			lo = Math.imul(al4, bl0);
+			mid = Math.imul(al4, bh0);
+			mid = mid + Math.imul(ah4, bl0) | 0;
+			hi = Math.imul(ah4, bh0);
+			lo = lo + Math.imul(al3, bl1) | 0;
+			mid = mid + Math.imul(al3, bh1) | 0;
+			mid = mid + Math.imul(ah3, bl1) | 0;
+			hi = hi + Math.imul(ah3, bh1) | 0;
+			lo = lo + Math.imul(al2, bl2) | 0;
+			mid = mid + Math.imul(al2, bh2) | 0;
+			mid = mid + Math.imul(ah2, bl2) | 0;
+			hi = hi + Math.imul(ah2, bh2) | 0;
+			lo = lo + Math.imul(al1, bl3) | 0;
+			mid = mid + Math.imul(al1, bh3) | 0;
+			mid = mid + Math.imul(ah1, bl3) | 0;
+			hi = hi + Math.imul(ah1, bh3) | 0;
+			lo = lo + Math.imul(al0, bl4) | 0;
+			mid = mid + Math.imul(al0, bh4) | 0;
+			mid = mid + Math.imul(ah0, bl4) | 0;
+			hi = hi + Math.imul(ah0, bh4) | 0;
+			var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
+			w4 &= 67108863;
+			lo = Math.imul(al5, bl0);
+			mid = Math.imul(al5, bh0);
+			mid = mid + Math.imul(ah5, bl0) | 0;
+			hi = Math.imul(ah5, bh0);
+			lo = lo + Math.imul(al4, bl1) | 0;
+			mid = mid + Math.imul(al4, bh1) | 0;
+			mid = mid + Math.imul(ah4, bl1) | 0;
+			hi = hi + Math.imul(ah4, bh1) | 0;
+			lo = lo + Math.imul(al3, bl2) | 0;
+			mid = mid + Math.imul(al3, bh2) | 0;
+			mid = mid + Math.imul(ah3, bl2) | 0;
+			hi = hi + Math.imul(ah3, bh2) | 0;
+			lo = lo + Math.imul(al2, bl3) | 0;
+			mid = mid + Math.imul(al2, bh3) | 0;
+			mid = mid + Math.imul(ah2, bl3) | 0;
+			hi = hi + Math.imul(ah2, bh3) | 0;
+			lo = lo + Math.imul(al1, bl4) | 0;
+			mid = mid + Math.imul(al1, bh4) | 0;
+			mid = mid + Math.imul(ah1, bl4) | 0;
+			hi = hi + Math.imul(ah1, bh4) | 0;
+			lo = lo + Math.imul(al0, bl5) | 0;
+			mid = mid + Math.imul(al0, bh5) | 0;
+			mid = mid + Math.imul(ah0, bl5) | 0;
+			hi = hi + Math.imul(ah0, bh5) | 0;
+			var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
+			w5 &= 67108863;
+			lo = Math.imul(al6, bl0);
+			mid = Math.imul(al6, bh0);
+			mid = mid + Math.imul(ah6, bl0) | 0;
+			hi = Math.imul(ah6, bh0);
+			lo = lo + Math.imul(al5, bl1) | 0;
+			mid = mid + Math.imul(al5, bh1) | 0;
+			mid = mid + Math.imul(ah5, bl1) | 0;
+			hi = hi + Math.imul(ah5, bh1) | 0;
+			lo = lo + Math.imul(al4, bl2) | 0;
+			mid = mid + Math.imul(al4, bh2) | 0;
+			mid = mid + Math.imul(ah4, bl2) | 0;
+			hi = hi + Math.imul(ah4, bh2) | 0;
+			lo = lo + Math.imul(al3, bl3) | 0;
+			mid = mid + Math.imul(al3, bh3) | 0;
+			mid = mid + Math.imul(ah3, bl3) | 0;
+			hi = hi + Math.imul(ah3, bh3) | 0;
+			lo = lo + Math.imul(al2, bl4) | 0;
+			mid = mid + Math.imul(al2, bh4) | 0;
+			mid = mid + Math.imul(ah2, bl4) | 0;
+			hi = hi + Math.imul(ah2, bh4) | 0;
+			lo = lo + Math.imul(al1, bl5) | 0;
+			mid = mid + Math.imul(al1, bh5) | 0;
+			mid = mid + Math.imul(ah1, bl5) | 0;
+			hi = hi + Math.imul(ah1, bh5) | 0;
+			lo = lo + Math.imul(al0, bl6) | 0;
+			mid = mid + Math.imul(al0, bh6) | 0;
+			mid = mid + Math.imul(ah0, bl6) | 0;
+			hi = hi + Math.imul(ah0, bh6) | 0;
+			var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
+			w6 &= 67108863;
+			lo = Math.imul(al7, bl0);
+			mid = Math.imul(al7, bh0);
+			mid = mid + Math.imul(ah7, bl0) | 0;
+			hi = Math.imul(ah7, bh0);
+			lo = lo + Math.imul(al6, bl1) | 0;
+			mid = mid + Math.imul(al6, bh1) | 0;
+			mid = mid + Math.imul(ah6, bl1) | 0;
+			hi = hi + Math.imul(ah6, bh1) | 0;
+			lo = lo + Math.imul(al5, bl2) | 0;
+			mid = mid + Math.imul(al5, bh2) | 0;
+			mid = mid + Math.imul(ah5, bl2) | 0;
+			hi = hi + Math.imul(ah5, bh2) | 0;
+			lo = lo + Math.imul(al4, bl3) | 0;
+			mid = mid + Math.imul(al4, bh3) | 0;
+			mid = mid + Math.imul(ah4, bl3) | 0;
+			hi = hi + Math.imul(ah4, bh3) | 0;
+			lo = lo + Math.imul(al3, bl4) | 0;
+			mid = mid + Math.imul(al3, bh4) | 0;
+			mid = mid + Math.imul(ah3, bl4) | 0;
+			hi = hi + Math.imul(ah3, bh4) | 0;
+			lo = lo + Math.imul(al2, bl5) | 0;
+			mid = mid + Math.imul(al2, bh5) | 0;
+			mid = mid + Math.imul(ah2, bl5) | 0;
+			hi = hi + Math.imul(ah2, bh5) | 0;
+			lo = lo + Math.imul(al1, bl6) | 0;
+			mid = mid + Math.imul(al1, bh6) | 0;
+			mid = mid + Math.imul(ah1, bl6) | 0;
+			hi = hi + Math.imul(ah1, bh6) | 0;
+			lo = lo + Math.imul(al0, bl7) | 0;
+			mid = mid + Math.imul(al0, bh7) | 0;
+			mid = mid + Math.imul(ah0, bl7) | 0;
+			hi = hi + Math.imul(ah0, bh7) | 0;
+			var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
+			w7 &= 67108863;
+			lo = Math.imul(al8, bl0);
+			mid = Math.imul(al8, bh0);
+			mid = mid + Math.imul(ah8, bl0) | 0;
+			hi = Math.imul(ah8, bh0);
+			lo = lo + Math.imul(al7, bl1) | 0;
+			mid = mid + Math.imul(al7, bh1) | 0;
+			mid = mid + Math.imul(ah7, bl1) | 0;
+			hi = hi + Math.imul(ah7, bh1) | 0;
+			lo = lo + Math.imul(al6, bl2) | 0;
+			mid = mid + Math.imul(al6, bh2) | 0;
+			mid = mid + Math.imul(ah6, bl2) | 0;
+			hi = hi + Math.imul(ah6, bh2) | 0;
+			lo = lo + Math.imul(al5, bl3) | 0;
+			mid = mid + Math.imul(al5, bh3) | 0;
+			mid = mid + Math.imul(ah5, bl3) | 0;
+			hi = hi + Math.imul(ah5, bh3) | 0;
+			lo = lo + Math.imul(al4, bl4) | 0;
+			mid = mid + Math.imul(al4, bh4) | 0;
+			mid = mid + Math.imul(ah4, bl4) | 0;
+			hi = hi + Math.imul(ah4, bh4) | 0;
+			lo = lo + Math.imul(al3, bl5) | 0;
+			mid = mid + Math.imul(al3, bh5) | 0;
+			mid = mid + Math.imul(ah3, bl5) | 0;
+			hi = hi + Math.imul(ah3, bh5) | 0;
+			lo = lo + Math.imul(al2, bl6) | 0;
+			mid = mid + Math.imul(al2, bh6) | 0;
+			mid = mid + Math.imul(ah2, bl6) | 0;
+			hi = hi + Math.imul(ah2, bh6) | 0;
+			lo = lo + Math.imul(al1, bl7) | 0;
+			mid = mid + Math.imul(al1, bh7) | 0;
+			mid = mid + Math.imul(ah1, bl7) | 0;
+			hi = hi + Math.imul(ah1, bh7) | 0;
+			lo = lo + Math.imul(al0, bl8) | 0;
+			mid = mid + Math.imul(al0, bh8) | 0;
+			mid = mid + Math.imul(ah0, bl8) | 0;
+			hi = hi + Math.imul(ah0, bh8) | 0;
+			var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
+			w8 &= 67108863;
+			lo = Math.imul(al9, bl0);
+			mid = Math.imul(al9, bh0);
+			mid = mid + Math.imul(ah9, bl0) | 0;
+			hi = Math.imul(ah9, bh0);
+			lo = lo + Math.imul(al8, bl1) | 0;
+			mid = mid + Math.imul(al8, bh1) | 0;
+			mid = mid + Math.imul(ah8, bl1) | 0;
+			hi = hi + Math.imul(ah8, bh1) | 0;
+			lo = lo + Math.imul(al7, bl2) | 0;
+			mid = mid + Math.imul(al7, bh2) | 0;
+			mid = mid + Math.imul(ah7, bl2) | 0;
+			hi = hi + Math.imul(ah7, bh2) | 0;
+			lo = lo + Math.imul(al6, bl3) | 0;
+			mid = mid + Math.imul(al6, bh3) | 0;
+			mid = mid + Math.imul(ah6, bl3) | 0;
+			hi = hi + Math.imul(ah6, bh3) | 0;
+			lo = lo + Math.imul(al5, bl4) | 0;
+			mid = mid + Math.imul(al5, bh4) | 0;
+			mid = mid + Math.imul(ah5, bl4) | 0;
+			hi = hi + Math.imul(ah5, bh4) | 0;
+			lo = lo + Math.imul(al4, bl5) | 0;
+			mid = mid + Math.imul(al4, bh5) | 0;
+			mid = mid + Math.imul(ah4, bl5) | 0;
+			hi = hi + Math.imul(ah4, bh5) | 0;
+			lo = lo + Math.imul(al3, bl6) | 0;
+			mid = mid + Math.imul(al3, bh6) | 0;
+			mid = mid + Math.imul(ah3, bl6) | 0;
+			hi = hi + Math.imul(ah3, bh6) | 0;
+			lo = lo + Math.imul(al2, bl7) | 0;
+			mid = mid + Math.imul(al2, bh7) | 0;
+			mid = mid + Math.imul(ah2, bl7) | 0;
+			hi = hi + Math.imul(ah2, bh7) | 0;
+			lo = lo + Math.imul(al1, bl8) | 0;
+			mid = mid + Math.imul(al1, bh8) | 0;
+			mid = mid + Math.imul(ah1, bl8) | 0;
+			hi = hi + Math.imul(ah1, bh8) | 0;
+			lo = lo + Math.imul(al0, bl9) | 0;
+			mid = mid + Math.imul(al0, bh9) | 0;
+			mid = mid + Math.imul(ah0, bl9) | 0;
+			hi = hi + Math.imul(ah0, bh9) | 0;
+			var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
+			w9 &= 67108863;
+			lo = Math.imul(al9, bl1);
+			mid = Math.imul(al9, bh1);
+			mid = mid + Math.imul(ah9, bl1) | 0;
+			hi = Math.imul(ah9, bh1);
+			lo = lo + Math.imul(al8, bl2) | 0;
+			mid = mid + Math.imul(al8, bh2) | 0;
+			mid = mid + Math.imul(ah8, bl2) | 0;
+			hi = hi + Math.imul(ah8, bh2) | 0;
+			lo = lo + Math.imul(al7, bl3) | 0;
+			mid = mid + Math.imul(al7, bh3) | 0;
+			mid = mid + Math.imul(ah7, bl3) | 0;
+			hi = hi + Math.imul(ah7, bh3) | 0;
+			lo = lo + Math.imul(al6, bl4) | 0;
+			mid = mid + Math.imul(al6, bh4) | 0;
+			mid = mid + Math.imul(ah6, bl4) | 0;
+			hi = hi + Math.imul(ah6, bh4) | 0;
+			lo = lo + Math.imul(al5, bl5) | 0;
+			mid = mid + Math.imul(al5, bh5) | 0;
+			mid = mid + Math.imul(ah5, bl5) | 0;
+			hi = hi + Math.imul(ah5, bh5) | 0;
+			lo = lo + Math.imul(al4, bl6) | 0;
+			mid = mid + Math.imul(al4, bh6) | 0;
+			mid = mid + Math.imul(ah4, bl6) | 0;
+			hi = hi + Math.imul(ah4, bh6) | 0;
+			lo = lo + Math.imul(al3, bl7) | 0;
+			mid = mid + Math.imul(al3, bh7) | 0;
+			mid = mid + Math.imul(ah3, bl7) | 0;
+			hi = hi + Math.imul(ah3, bh7) | 0;
+			lo = lo + Math.imul(al2, bl8) | 0;
+			mid = mid + Math.imul(al2, bh8) | 0;
+			mid = mid + Math.imul(ah2, bl8) | 0;
+			hi = hi + Math.imul(ah2, bh8) | 0;
+			lo = lo + Math.imul(al1, bl9) | 0;
+			mid = mid + Math.imul(al1, bh9) | 0;
+			mid = mid + Math.imul(ah1, bl9) | 0;
+			hi = hi + Math.imul(ah1, bh9) | 0;
+			var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
+			w10 &= 67108863;
+			lo = Math.imul(al9, bl2);
+			mid = Math.imul(al9, bh2);
+			mid = mid + Math.imul(ah9, bl2) | 0;
+			hi = Math.imul(ah9, bh2);
+			lo = lo + Math.imul(al8, bl3) | 0;
+			mid = mid + Math.imul(al8, bh3) | 0;
+			mid = mid + Math.imul(ah8, bl3) | 0;
+			hi = hi + Math.imul(ah8, bh3) | 0;
+			lo = lo + Math.imul(al7, bl4) | 0;
+			mid = mid + Math.imul(al7, bh4) | 0;
+			mid = mid + Math.imul(ah7, bl4) | 0;
+			hi = hi + Math.imul(ah7, bh4) | 0;
+			lo = lo + Math.imul(al6, bl5) | 0;
+			mid = mid + Math.imul(al6, bh5) | 0;
+			mid = mid + Math.imul(ah6, bl5) | 0;
+			hi = hi + Math.imul(ah6, bh5) | 0;
+			lo = lo + Math.imul(al5, bl6) | 0;
+			mid = mid + Math.imul(al5, bh6) | 0;
+			mid = mid + Math.imul(ah5, bl6) | 0;
+			hi = hi + Math.imul(ah5, bh6) | 0;
+			lo = lo + Math.imul(al4, bl7) | 0;
+			mid = mid + Math.imul(al4, bh7) | 0;
+			mid = mid + Math.imul(ah4, bl7) | 0;
+			hi = hi + Math.imul(ah4, bh7) | 0;
+			lo = lo + Math.imul(al3, bl8) | 0;
+			mid = mid + Math.imul(al3, bh8) | 0;
+			mid = mid + Math.imul(ah3, bl8) | 0;
+			hi = hi + Math.imul(ah3, bh8) | 0;
+			lo = lo + Math.imul(al2, bl9) | 0;
+			mid = mid + Math.imul(al2, bh9) | 0;
+			mid = mid + Math.imul(ah2, bl9) | 0;
+			hi = hi + Math.imul(ah2, bh9) | 0;
+			var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
+			w11 &= 67108863;
+			lo = Math.imul(al9, bl3);
+			mid = Math.imul(al9, bh3);
+			mid = mid + Math.imul(ah9, bl3) | 0;
+			hi = Math.imul(ah9, bh3);
+			lo = lo + Math.imul(al8, bl4) | 0;
+			mid = mid + Math.imul(al8, bh4) | 0;
+			mid = mid + Math.imul(ah8, bl4) | 0;
+			hi = hi + Math.imul(ah8, bh4) | 0;
+			lo = lo + Math.imul(al7, bl5) | 0;
+			mid = mid + Math.imul(al7, bh5) | 0;
+			mid = mid + Math.imul(ah7, bl5) | 0;
+			hi = hi + Math.imul(ah7, bh5) | 0;
+			lo = lo + Math.imul(al6, bl6) | 0;
+			mid = mid + Math.imul(al6, bh6) | 0;
+			mid = mid + Math.imul(ah6, bl6) | 0;
+			hi = hi + Math.imul(ah6, bh6) | 0;
+			lo = lo + Math.imul(al5, bl7) | 0;
+			mid = mid + Math.imul(al5, bh7) | 0;
+			mid = mid + Math.imul(ah5, bl7) | 0;
+			hi = hi + Math.imul(ah5, bh7) | 0;
+			lo = lo + Math.imul(al4, bl8) | 0;
+			mid = mid + Math.imul(al4, bh8) | 0;
+			mid = mid + Math.imul(ah4, bl8) | 0;
+			hi = hi + Math.imul(ah4, bh8) | 0;
+			lo = lo + Math.imul(al3, bl9) | 0;
+			mid = mid + Math.imul(al3, bh9) | 0;
+			mid = mid + Math.imul(ah3, bl9) | 0;
+			hi = hi + Math.imul(ah3, bh9) | 0;
+			var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
+			w12 &= 67108863;
+			lo = Math.imul(al9, bl4);
+			mid = Math.imul(al9, bh4);
+			mid = mid + Math.imul(ah9, bl4) | 0;
+			hi = Math.imul(ah9, bh4);
+			lo = lo + Math.imul(al8, bl5) | 0;
+			mid = mid + Math.imul(al8, bh5) | 0;
+			mid = mid + Math.imul(ah8, bl5) | 0;
+			hi = hi + Math.imul(ah8, bh5) | 0;
+			lo = lo + Math.imul(al7, bl6) | 0;
+			mid = mid + Math.imul(al7, bh6) | 0;
+			mid = mid + Math.imul(ah7, bl6) | 0;
+			hi = hi + Math.imul(ah7, bh6) | 0;
+			lo = lo + Math.imul(al6, bl7) | 0;
+			mid = mid + Math.imul(al6, bh7) | 0;
+			mid = mid + Math.imul(ah6, bl7) | 0;
+			hi = hi + Math.imul(ah6, bh7) | 0;
+			lo = lo + Math.imul(al5, bl8) | 0;
+			mid = mid + Math.imul(al5, bh8) | 0;
+			mid = mid + Math.imul(ah5, bl8) | 0;
+			hi = hi + Math.imul(ah5, bh8) | 0;
+			lo = lo + Math.imul(al4, bl9) | 0;
+			mid = mid + Math.imul(al4, bh9) | 0;
+			mid = mid + Math.imul(ah4, bl9) | 0;
+			hi = hi + Math.imul(ah4, bh9) | 0;
+			var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
+			w13 &= 67108863;
+			lo = Math.imul(al9, bl5);
+			mid = Math.imul(al9, bh5);
+			mid = mid + Math.imul(ah9, bl5) | 0;
+			hi = Math.imul(ah9, bh5);
+			lo = lo + Math.imul(al8, bl6) | 0;
+			mid = mid + Math.imul(al8, bh6) | 0;
+			mid = mid + Math.imul(ah8, bl6) | 0;
+			hi = hi + Math.imul(ah8, bh6) | 0;
+			lo = lo + Math.imul(al7, bl7) | 0;
+			mid = mid + Math.imul(al7, bh7) | 0;
+			mid = mid + Math.imul(ah7, bl7) | 0;
+			hi = hi + Math.imul(ah7, bh7) | 0;
+			lo = lo + Math.imul(al6, bl8) | 0;
+			mid = mid + Math.imul(al6, bh8) | 0;
+			mid = mid + Math.imul(ah6, bl8) | 0;
+			hi = hi + Math.imul(ah6, bh8) | 0;
+			lo = lo + Math.imul(al5, bl9) | 0;
+			mid = mid + Math.imul(al5, bh9) | 0;
+			mid = mid + Math.imul(ah5, bl9) | 0;
+			hi = hi + Math.imul(ah5, bh9) | 0;
+			var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
+			w14 &= 67108863;
+			lo = Math.imul(al9, bl6);
+			mid = Math.imul(al9, bh6);
+			mid = mid + Math.imul(ah9, bl6) | 0;
+			hi = Math.imul(ah9, bh6);
+			lo = lo + Math.imul(al8, bl7) | 0;
+			mid = mid + Math.imul(al8, bh7) | 0;
+			mid = mid + Math.imul(ah8, bl7) | 0;
+			hi = hi + Math.imul(ah8, bh7) | 0;
+			lo = lo + Math.imul(al7, bl8) | 0;
+			mid = mid + Math.imul(al7, bh8) | 0;
+			mid = mid + Math.imul(ah7, bl8) | 0;
+			hi = hi + Math.imul(ah7, bh8) | 0;
+			lo = lo + Math.imul(al6, bl9) | 0;
+			mid = mid + Math.imul(al6, bh9) | 0;
+			mid = mid + Math.imul(ah6, bl9) | 0;
+			hi = hi + Math.imul(ah6, bh9) | 0;
+			var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
+			w15 &= 67108863;
+			lo = Math.imul(al9, bl7);
+			mid = Math.imul(al9, bh7);
+			mid = mid + Math.imul(ah9, bl7) | 0;
+			hi = Math.imul(ah9, bh7);
+			lo = lo + Math.imul(al8, bl8) | 0;
+			mid = mid + Math.imul(al8, bh8) | 0;
+			mid = mid + Math.imul(ah8, bl8) | 0;
+			hi = hi + Math.imul(ah8, bh8) | 0;
+			lo = lo + Math.imul(al7, bl9) | 0;
+			mid = mid + Math.imul(al7, bh9) | 0;
+			mid = mid + Math.imul(ah7, bl9) | 0;
+			hi = hi + Math.imul(ah7, bh9) | 0;
+			var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
+			w16 &= 67108863;
+			lo = Math.imul(al9, bl8);
+			mid = Math.imul(al9, bh8);
+			mid = mid + Math.imul(ah9, bl8) | 0;
+			hi = Math.imul(ah9, bh8);
+			lo = lo + Math.imul(al8, bl9) | 0;
+			mid = mid + Math.imul(al8, bh9) | 0;
+			mid = mid + Math.imul(ah8, bl9) | 0;
+			hi = hi + Math.imul(ah8, bh9) | 0;
+			var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
+			w17 &= 67108863;
+			lo = Math.imul(al9, bl9);
+			mid = Math.imul(al9, bh9);
+			mid = mid + Math.imul(ah9, bl9) | 0;
+			hi = Math.imul(ah9, bh9);
+			var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
+			c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
+			w18 &= 67108863;
+			o[0] = w0;
+			o[1] = w1;
+			o[2] = w2;
+			o[3] = w3;
+			o[4] = w4;
+			o[5] = w5;
+			o[6] = w6;
+			o[7] = w7;
+			o[8] = w8;
+			o[9] = w9;
+			o[10] = w10;
+			o[11] = w11;
+			o[12] = w12;
+			o[13] = w13;
+			o[14] = w14;
+			o[15] = w15;
+			o[16] = w16;
+			o[17] = w17;
+			o[18] = w18;
+			if (c !== 0) {
+				o[19] = c;
+				out.length++;
+			}
+			return out;
+		};
+		if (!Math.imul) comb10MulTo = smallMulTo;
+		function bigMulTo(self, num, out) {
+			out.negative = num.negative ^ self.negative;
+			out.length = self.length + num.length;
+			var carry = 0;
+			var hncarry = 0;
+			for (var k = 0; k < out.length - 1; k++) {
+				var ncarry = hncarry;
+				hncarry = 0;
+				var rword = carry & 67108863;
+				var maxJ = Math.min(k, num.length - 1);
+				for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {
+					var i = k - j;
+					var r = (self.words[i] | 0) * (num.words[j] | 0);
+					var lo = r & 67108863;
+					ncarry = ncarry + (r / 67108864 | 0) | 0;
+					lo = lo + rword | 0;
+					rword = lo & 67108863;
+					ncarry = ncarry + (lo >>> 26) | 0;
+					hncarry += ncarry >>> 26;
+					ncarry &= 67108863;
+				}
+				out.words[k] = rword;
+				carry = ncarry;
+				ncarry = hncarry;
+			}
+			if (carry !== 0) out.words[k] = carry;
+			else out.length--;
+			return out._strip();
+		}
+		function jumboMulTo(self, num, out) {
+			return bigMulTo(self, num, out);
+		}
+		BN.prototype.mulTo = function mulTo(num, out) {
+			var res;
+			var len = this.length + num.length;
+			if (this.length === 10 && num.length === 10) res = comb10MulTo(this, num, out);
+			else if (len < 63) res = smallMulTo(this, num, out);
+			else if (len < 1024) res = bigMulTo(this, num, out);
+			else res = jumboMulTo(this, num, out);
+			return res;
+		};
+		function FFTM(x, y) {
+			this.x = x;
+			this.y = y;
+		}
+		FFTM.prototype.makeRBT = function makeRBT(N) {
+			var t = new Array(N);
+			var l = BN.prototype._countBits(N) - 1;
+			for (var i = 0; i < N; i++) t[i] = this.revBin(i, l, N);
+			return t;
+		};
+		FFTM.prototype.revBin = function revBin(x, l, N) {
+			if (x === 0 || x === N - 1) return x;
+			var rb = 0;
+			for (var i = 0; i < l; i++) {
+				rb |= (x & 1) << l - i - 1;
+				x >>= 1;
+			}
+			return rb;
+		};
+		FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
+			for (var i = 0; i < N; i++) {
+				rtws[i] = rws[rbt[i]];
+				itws[i] = iws[rbt[i]];
+			}
+		};
+		FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
+			this.permute(rbt, rws, iws, rtws, itws, N);
+			for (var s = 1; s < N; s <<= 1) {
+				var l = s << 1;
+				var rtwdf = Math.cos(2 * Math.PI / l);
+				var itwdf = Math.sin(2 * Math.PI / l);
+				for (var p = 0; p < N; p += l) {
+					var rtwdf_ = rtwdf;
+					var itwdf_ = itwdf;
+					for (var j = 0; j < s; j++) {
+						var re = rtws[p + j];
+						var ie = itws[p + j];
+						var ro = rtws[p + j + s];
+						var io = itws[p + j + s];
+						var rx = rtwdf_ * ro - itwdf_ * io;
+						io = rtwdf_ * io + itwdf_ * ro;
+						ro = rx;
+						rtws[p + j] = re + ro;
+						itws[p + j] = ie + io;
+						rtws[p + j + s] = re - ro;
+						itws[p + j + s] = ie - io;
+						if (j !== l) {
+							rx = rtwdf * rtwdf_ - itwdf * itwdf_;
+							itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
+							rtwdf_ = rx;
+						}
+					}
+				}
+			}
+		};
+		FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
+			var N = Math.max(m, n) | 1;
+			var odd = N & 1;
+			var i = 0;
+			for (N = N / 2 | 0; N; N = N >>> 1) i++;
+			return 1 << i + 1 + odd;
+		};
+		FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
+			if (N <= 1) return;
+			for (var i = 0; i < N / 2; i++) {
+				var t = rws[i];
+				rws[i] = rws[N - i - 1];
+				rws[N - i - 1] = t;
+				t = iws[i];
+				iws[i] = -iws[N - i - 1];
+				iws[N - i - 1] = -t;
+			}
+		};
+		FFTM.prototype.normalize13b = function normalize13b(ws, N) {
+			var carry = 0;
+			for (var i = 0; i < N / 2; i++) {
+				var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
+				ws[i] = w & 67108863;
+				if (w < 67108864) carry = 0;
+				else carry = w / 67108864 | 0;
+			}
+			return ws;
+		};
+		FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
+			var carry = 0;
+			for (var i = 0; i < len; i++) {
+				carry = carry + (ws[i] | 0);
+				rws[2 * i] = carry & 8191;
+				carry = carry >>> 13;
+				rws[2 * i + 1] = carry & 8191;
+				carry = carry >>> 13;
+			}
+			for (i = 2 * len; i < N; ++i) rws[i] = 0;
+			assert(carry === 0);
+			assert((carry & -8192) === 0);
+		};
+		FFTM.prototype.stub = function stub(N) {
+			var ph = new Array(N);
+			for (var i = 0; i < N; i++) ph[i] = 0;
+			return ph;
+		};
+		FFTM.prototype.mulp = function mulp(x, y, out) {
+			var N = 2 * this.guessLen13b(x.length, y.length);
+			var rbt = this.makeRBT(N);
+			var _ = this.stub(N);
+			var rws = new Array(N);
+			var rwst = new Array(N);
+			var iwst = new Array(N);
+			var nrws = new Array(N);
+			var nrwst = new Array(N);
+			var niwst = new Array(N);
+			var rmws = out.words;
+			rmws.length = N;
+			this.convert13b(x.words, x.length, rws, N);
+			this.convert13b(y.words, y.length, nrws, N);
+			this.transform(rws, _, rwst, iwst, N, rbt);
+			this.transform(nrws, _, nrwst, niwst, N, rbt);
+			for (var i = 0; i < N; i++) {
+				var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
+				iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
+				rwst[i] = rx;
+			}
+			this.conjugate(rwst, iwst, N);
+			this.transform(rwst, iwst, rmws, _, N, rbt);
+			this.conjugate(rmws, _, N);
+			this.normalize13b(rmws, N);
+			out.negative = x.negative ^ y.negative;
+			out.length = x.length + y.length;
+			return out._strip();
+		};
+		BN.prototype.mul = function mul(num) {
+			var out = new BN(null);
+			out.words = new Array(this.length + num.length);
+			return this.mulTo(num, out);
+		};
+		BN.prototype.mulf = function mulf(num) {
+			var out = new BN(null);
+			out.words = new Array(this.length + num.length);
+			return jumboMulTo(this, num, out);
+		};
+		BN.prototype.imul = function imul(num) {
+			return this.clone().mulTo(num, this);
+		};
+		BN.prototype.imuln = function imuln(num) {
+			var isNegNum = num < 0;
+			if (isNegNum) num = -num;
+			assert(typeof num === "number");
+			assert(num < 67108864);
+			var carry = 0;
+			for (var i = 0; i < this.length; i++) {
+				var w = (this.words[i] | 0) * num;
+				var lo = (w & 67108863) + (carry & 67108863);
+				carry >>= 26;
+				carry += w / 67108864 | 0;
+				carry += lo >>> 26;
+				this.words[i] = lo & 67108863;
+			}
+			if (carry !== 0) {
+				this.words[i] = carry;
+				this.length++;
+			}
+			this.length = num === 0 ? 1 : this.length;
+			return isNegNum ? this.ineg() : this;
+		};
+		BN.prototype.muln = function muln(num) {
+			return this.clone().imuln(num);
+		};
+		BN.prototype.sqr = function sqr() {
+			return this.mul(this);
+		};
+		BN.prototype.isqr = function isqr() {
+			return this.imul(this.clone());
+		};
+		BN.prototype.pow = function pow(num) {
+			var w = toBitArray(num);
+			if (w.length === 0) return new BN(1);
+			var res = this;
+			for (var i = 0; i < w.length; i++, res = res.sqr()) if (w[i] !== 0) break;
+			if (++i < w.length) for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {
+				if (w[i] === 0) continue;
+				res = res.mul(q);
+			}
+			return res;
+		};
+		BN.prototype.iushln = function iushln(bits) {
+			assert(typeof bits === "number" && bits >= 0);
+			var r = bits % 26;
+			var s = (bits - r) / 26;
+			var carryMask = 67108863 >>> 26 - r << 26 - r;
+			var i;
+			if (r !== 0) {
+				var carry = 0;
+				for (i = 0; i < this.length; i++) {
+					var newCarry = this.words[i] & carryMask;
+					var c = (this.words[i] | 0) - newCarry << r;
+					this.words[i] = c | carry;
+					carry = newCarry >>> 26 - r;
+				}
+				if (carry) {
+					this.words[i] = carry;
+					this.length++;
+				}
+			}
+			if (s !== 0) {
+				for (i = this.length - 1; i >= 0; i--) this.words[i + s] = this.words[i];
+				for (i = 0; i < s; i++) this.words[i] = 0;
+				this.length += s;
+			}
+			return this._strip();
+		};
+		BN.prototype.ishln = function ishln(bits) {
+			assert(this.negative === 0);
+			return this.iushln(bits);
+		};
+		BN.prototype.iushrn = function iushrn(bits, hint, extended) {
+			assert(typeof bits === "number" && bits >= 0);
+			var h;
+			if (hint) h = (hint - hint % 26) / 26;
+			else h = 0;
+			var r = bits % 26;
+			var s = Math.min((bits - r) / 26, this.length);
+			var mask = 67108863 ^ 67108863 >>> r << r;
+			var maskedWords = extended;
+			h -= s;
+			h = Math.max(0, h);
+			if (maskedWords) {
+				for (var i = 0; i < s; i++) maskedWords.words[i] = this.words[i];
+				maskedWords.length = s;
+			}
+			if (s === 0) {} else if (this.length > s) {
+				this.length -= s;
+				for (i = 0; i < this.length; i++) this.words[i] = this.words[i + s];
+			} else {
+				this.words[0] = 0;
+				this.length = 1;
+			}
+			var carry = 0;
+			for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {
+				var word = this.words[i] | 0;
+				this.words[i] = carry << 26 - r | word >>> r;
+				carry = word & mask;
+			}
+			if (maskedWords && carry !== 0) maskedWords.words[maskedWords.length++] = carry;
+			if (this.length === 0) {
+				this.words[0] = 0;
+				this.length = 1;
+			}
+			return this._strip();
+		};
+		BN.prototype.ishrn = function ishrn(bits, hint, extended) {
+			assert(this.negative === 0);
+			return this.iushrn(bits, hint, extended);
+		};
+		BN.prototype.shln = function shln(bits) {
+			return this.clone().ishln(bits);
+		};
+		BN.prototype.ushln = function ushln(bits) {
+			return this.clone().iushln(bits);
+		};
+		BN.prototype.shrn = function shrn(bits) {
+			return this.clone().ishrn(bits);
+		};
+		BN.prototype.ushrn = function ushrn(bits) {
+			return this.clone().iushrn(bits);
+		};
+		BN.prototype.testn = function testn(bit) {
+			assert(typeof bit === "number" && bit >= 0);
+			var r = bit % 26;
+			var s = (bit - r) / 26;
+			var q = 1 << r;
+			if (this.length <= s) return false;
+			return !!(this.words[s] & q);
+		};
+		BN.prototype.imaskn = function imaskn(bits) {
+			assert(typeof bits === "number" && bits >= 0);
+			var r = bits % 26;
+			var s = (bits - r) / 26;
+			assert(this.negative === 0, "imaskn works only with positive numbers");
+			if (this.length <= s) return this;
+			if (r !== 0) s++;
+			this.length = Math.min(s, this.length);
+			if (r !== 0) {
+				var mask = 67108863 ^ 67108863 >>> r << r;
+				this.words[this.length - 1] &= mask;
+			}
+			if (this.length === 0) {
+				this.words[0] = 0;
+				this.length = 1;
+			}
+			return this._strip();
+		};
+		BN.prototype.maskn = function maskn(bits) {
+			return this.clone().imaskn(bits);
+		};
+		BN.prototype.iaddn = function iaddn(num) {
+			assert(typeof num === "number");
+			assert(num < 67108864);
+			if (num < 0) return this.isubn(-num);
+			if (this.negative !== 0) {
+				if (this.length === 1 && (this.words[0] | 0) <= num) {
+					this.words[0] = num - (this.words[0] | 0);
+					this.negative = 0;
+					return this;
+				}
+				this.negative = 0;
+				this.isubn(num);
+				this.negative = 1;
+				return this;
+			}
+			return this._iaddn(num);
+		};
+		BN.prototype._iaddn = function _iaddn(num) {
+			this.words[0] += num;
+			for (var i = 0; i < this.length && this.words[i] >= 67108864; i++) {
+				this.words[i] -= 67108864;
+				if (i === this.length - 1) this.words[i + 1] = 1;
+				else this.words[i + 1]++;
+			}
+			this.length = Math.max(this.length, i + 1);
+			return this;
+		};
+		BN.prototype.isubn = function isubn(num) {
+			assert(typeof num === "number");
+			assert(num < 67108864);
+			if (num < 0) return this.iaddn(-num);
+			if (this.negative !== 0) {
+				this.negative = 0;
+				this.iaddn(num);
+				this.negative = 1;
+				return this;
+			}
+			this.words[0] -= num;
+			if (this.length === 1 && this.words[0] < 0) {
+				this.words[0] = -this.words[0];
+				this.negative = 1;
+			} else for (var i = 0; i < this.length && this.words[i] < 0; i++) {
+				this.words[i] += 67108864;
+				this.words[i + 1] -= 1;
+			}
+			return this._strip();
+		};
+		BN.prototype.addn = function addn(num) {
+			return this.clone().iaddn(num);
+		};
+		BN.prototype.subn = function subn(num) {
+			return this.clone().isubn(num);
+		};
+		BN.prototype.iabs = function iabs() {
+			this.negative = 0;
+			return this;
+		};
+		BN.prototype.abs = function abs() {
+			return this.clone().iabs();
+		};
+		BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
+			var len = num.length + shift;
+			var i;
+			this._expand(len);
+			var w;
+			var carry = 0;
+			for (i = 0; i < num.length; i++) {
+				w = (this.words[i + shift] | 0) + carry;
+				var right = (num.words[i] | 0) * mul;
+				w -= right & 67108863;
+				carry = (w >> 26) - (right / 67108864 | 0);
+				this.words[i + shift] = w & 67108863;
+			}
+			for (; i < this.length - shift; i++) {
+				w = (this.words[i + shift] | 0) + carry;
+				carry = w >> 26;
+				this.words[i + shift] = w & 67108863;
+			}
+			if (carry === 0) return this._strip();
+			assert(carry === -1);
+			carry = 0;
+			for (i = 0; i < this.length; i++) {
+				w = -(this.words[i] | 0) + carry;
+				carry = w >> 26;
+				this.words[i] = w & 67108863;
+			}
+			this.negative = 1;
+			return this._strip();
+		};
+		BN.prototype._wordDiv = function _wordDiv(num, mode) {
+			var shift = this.length - num.length;
+			var a = this.clone();
+			var b = num;
+			var bhi = b.words[b.length - 1] | 0;
+			shift = 26 - this._countBits(bhi);
+			if (shift !== 0) {
+				b = b.ushln(shift);
+				a.iushln(shift);
+				bhi = b.words[b.length - 1] | 0;
+			}
+			var m = a.length - b.length;
+			var q;
+			if (mode !== "mod") {
+				q = new BN(null);
+				q.length = m + 1;
+				q.words = new Array(q.length);
+				for (var i = 0; i < q.length; i++) q.words[i] = 0;
+			}
+			var diff = a.clone()._ishlnsubmul(b, 1, m);
+			if (diff.negative === 0) {
+				a = diff;
+				if (q) q.words[m] = 1;
+			}
+			for (var j = m - 1; j >= 0; j--) {
+				var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
+				qj = Math.min(qj / bhi | 0, 67108863);
+				a._ishlnsubmul(b, qj, j);
+				while (a.negative !== 0) {
+					qj--;
+					a.negative = 0;
+					a._ishlnsubmul(b, 1, j);
+					if (!a.isZero()) a.negative ^= 1;
+				}
+				if (q) q.words[j] = qj;
+			}
+			if (q) q._strip();
+			a._strip();
+			if (mode !== "div" && shift !== 0) a.iushrn(shift);
+			return {
+				div: q || null,
+				mod: a
+			};
+		};
+		BN.prototype.divmod = function divmod(num, mode, positive) {
+			assert(!num.isZero());
+			if (this.isZero()) return {
+				div: new BN(0),
+				mod: new BN(0)
+			};
+			var div, mod, res;
+			if (this.negative !== 0 && num.negative === 0) {
+				res = this.neg().divmod(num, mode);
+				if (mode !== "mod") div = res.div.neg();
+				if (mode !== "div") {
+					mod = res.mod.neg();
+					if (positive && mod.negative !== 0) mod.iadd(num);
+				}
+				return {
+					div,
+					mod
+				};
+			}
+			if (this.negative === 0 && num.negative !== 0) {
+				res = this.divmod(num.neg(), mode);
+				if (mode !== "mod") div = res.div.neg();
+				return {
+					div,
+					mod: res.mod
+				};
+			}
+			if ((this.negative & num.negative) !== 0) {
+				res = this.neg().divmod(num.neg(), mode);
+				if (mode !== "div") {
+					mod = res.mod.neg();
+					if (positive && mod.negative !== 0) mod.isub(num);
+				}
+				return {
+					div: res.div,
+					mod
+				};
+			}
+			if (num.length > this.length || this.cmp(num) < 0) return {
+				div: new BN(0),
+				mod: this
+			};
+			if (num.length === 1) {
+				if (mode === "div") return {
+					div: this.divn(num.words[0]),
+					mod: null
+				};
+				if (mode === "mod") return {
+					div: null,
+					mod: new BN(this.modrn(num.words[0]))
+				};
+				return {
+					div: this.divn(num.words[0]),
+					mod: new BN(this.modrn(num.words[0]))
+				};
+			}
+			return this._wordDiv(num, mode);
+		};
+		BN.prototype.div = function div(num) {
+			return this.divmod(num, "div", false).div;
+		};
+		BN.prototype.mod = function mod(num) {
+			return this.divmod(num, "mod", false).mod;
+		};
+		BN.prototype.umod = function umod(num) {
+			return this.divmod(num, "mod", true).mod;
+		};
+		BN.prototype.divRound = function divRound(num) {
+			var dm = this.divmod(num);
+			if (dm.mod.isZero()) return dm.div;
+			var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
+			var half = num.ushrn(1);
+			var r2 = num.andln(1);
+			var cmp = mod.cmp(half);
+			if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+			return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
+		};
+		BN.prototype.modrn = function modrn(num) {
+			var isNegNum = num < 0;
+			if (isNegNum) num = -num;
+			assert(num <= 67108863);
+			var p = (1 << 26) % num;
+			var acc = 0;
+			for (var i = this.length - 1; i >= 0; i--) acc = (p * acc + (this.words[i] | 0)) % num;
+			return isNegNum ? -acc : acc;
+		};
+		BN.prototype.modn = function modn(num) {
+			return this.modrn(num);
+		};
+		BN.prototype.idivn = function idivn(num) {
+			var isNegNum = num < 0;
+			if (isNegNum) num = -num;
+			assert(num <= 67108863);
+			var carry = 0;
+			for (var i = this.length - 1; i >= 0; i--) {
+				var w = (this.words[i] | 0) + carry * 67108864;
+				this.words[i] = w / num | 0;
+				carry = w % num;
+			}
+			this._strip();
+			return isNegNum ? this.ineg() : this;
+		};
+		BN.prototype.divn = function divn(num) {
+			return this.clone().idivn(num);
+		};
+		BN.prototype.egcd = function egcd(p) {
+			assert(p.negative === 0);
+			assert(!p.isZero());
+			var x = this;
+			var y = p.clone();
+			if (x.negative !== 0) x = x.umod(p);
+			else x = x.clone();
+			var A = new BN(1);
+			var B = new BN(0);
+			var C = new BN(0);
+			var D = new BN(1);
+			var g = 0;
+			while (x.isEven() && y.isEven()) {
+				x.iushrn(1);
+				y.iushrn(1);
+				++g;
+			}
+			var yp = y.clone();
+			var xp = x.clone();
+			while (!x.isZero()) {
+				for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+				if (i > 0) {
+					x.iushrn(i);
+					while (i-- > 0) {
+						if (A.isOdd() || B.isOdd()) {
+							A.iadd(yp);
+							B.isub(xp);
+						}
+						A.iushrn(1);
+						B.iushrn(1);
+					}
+				}
+				for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+				if (j > 0) {
+					y.iushrn(j);
+					while (j-- > 0) {
+						if (C.isOdd() || D.isOdd()) {
+							C.iadd(yp);
+							D.isub(xp);
+						}
+						C.iushrn(1);
+						D.iushrn(1);
+					}
+				}
+				if (x.cmp(y) >= 0) {
+					x.isub(y);
+					A.isub(C);
+					B.isub(D);
+				} else {
+					y.isub(x);
+					C.isub(A);
+					D.isub(B);
+				}
+			}
+			return {
+				a: C,
+				b: D,
+				gcd: y.iushln(g)
+			};
+		};
+		BN.prototype._invmp = function _invmp(p) {
+			assert(p.negative === 0);
+			assert(!p.isZero());
+			var a = this;
+			var b = p.clone();
+			if (a.negative !== 0) a = a.umod(p);
+			else a = a.clone();
+			var x1 = new BN(1);
+			var x2 = new BN(0);
+			var delta = b.clone();
+			while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
+				for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);
+				if (i > 0) {
+					a.iushrn(i);
+					while (i-- > 0) {
+						if (x1.isOdd()) x1.iadd(delta);
+						x1.iushrn(1);
+					}
+				}
+				for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);
+				if (j > 0) {
+					b.iushrn(j);
+					while (j-- > 0) {
+						if (x2.isOdd()) x2.iadd(delta);
+						x2.iushrn(1);
+					}
+				}
+				if (a.cmp(b) >= 0) {
+					a.isub(b);
+					x1.isub(x2);
+				} else {
+					b.isub(a);
+					x2.isub(x1);
+				}
+			}
+			var res;
+			if (a.cmpn(1) === 0) res = x1;
+			else res = x2;
+			if (res.cmpn(0) < 0) res.iadd(p);
+			return res;
+		};
+		BN.prototype.gcd = function gcd(num) {
+			if (this.isZero()) return num.abs();
+			if (num.isZero()) return this.abs();
+			var a = this.clone();
+			var b = num.clone();
+			a.negative = 0;
+			b.negative = 0;
+			for (var shift = 0; a.isEven() && b.isEven(); shift++) {
+				a.iushrn(1);
+				b.iushrn(1);
+			}
+			do {
+				while (a.isEven()) a.iushrn(1);
+				while (b.isEven()) b.iushrn(1);
+				var r = a.cmp(b);
+				if (r < 0) {
+					var t = a;
+					a = b;
+					b = t;
+				} else if (r === 0 || b.cmpn(1) === 0) break;
+				a.isub(b);
+			} while (true);
+			return b.iushln(shift);
+		};
+		BN.prototype.invm = function invm(num) {
+			return this.egcd(num).a.umod(num);
+		};
+		BN.prototype.isEven = function isEven() {
+			return (this.words[0] & 1) === 0;
+		};
+		BN.prototype.isOdd = function isOdd() {
+			return (this.words[0] & 1) === 1;
+		};
+		BN.prototype.andln = function andln(num) {
+			return this.words[0] & num;
+		};
+		BN.prototype.bincn = function bincn(bit) {
+			assert(typeof bit === "number");
+			var r = bit % 26;
+			var s = (bit - r) / 26;
+			var q = 1 << r;
+			if (this.length <= s) {
+				this._expand(s + 1);
+				this.words[s] |= q;
+				return this;
+			}
+			var carry = q;
+			for (var i = s; carry !== 0 && i < this.length; i++) {
+				var w = this.words[i] | 0;
+				w += carry;
+				carry = w >>> 26;
+				w &= 67108863;
+				this.words[i] = w;
+			}
+			if (carry !== 0) {
+				this.words[i] = carry;
+				this.length++;
+			}
+			return this;
+		};
+		BN.prototype.isZero = function isZero() {
+			return this.length === 1 && this.words[0] === 0;
+		};
+		BN.prototype.cmpn = function cmpn(num) {
+			var negative = num < 0;
+			if (this.negative !== 0 && !negative) return -1;
+			if (this.negative === 0 && negative) return 1;
+			this._strip();
+			var res;
+			if (this.length > 1) res = 1;
+			else {
+				if (negative) num = -num;
+				assert(num <= 67108863, "Number is too big");
+				var w = this.words[0] | 0;
+				res = w === num ? 0 : w < num ? -1 : 1;
+			}
+			if (this.negative !== 0) return -res | 0;
+			return res;
+		};
+		BN.prototype.cmp = function cmp(num) {
+			if (this.negative !== 0 && num.negative === 0) return -1;
+			if (this.negative === 0 && num.negative !== 0) return 1;
+			var res = this.ucmp(num);
+			if (this.negative !== 0) return -res | 0;
+			return res;
+		};
+		BN.prototype.ucmp = function ucmp(num) {
+			if (this.length > num.length) return 1;
+			if (this.length < num.length) return -1;
+			var res = 0;
+			for (var i = this.length - 1; i >= 0; i--) {
+				var a = this.words[i] | 0;
+				var b = num.words[i] | 0;
+				if (a === b) continue;
+				if (a < b) res = -1;
+				else if (a > b) res = 1;
+				break;
+			}
+			return res;
+		};
+		BN.prototype.gtn = function gtn(num) {
+			return this.cmpn(num) === 1;
+		};
+		BN.prototype.gt = function gt(num) {
+			return this.cmp(num) === 1;
+		};
+		BN.prototype.gten = function gten(num) {
+			return this.cmpn(num) >= 0;
+		};
+		BN.prototype.gte = function gte(num) {
+			return this.cmp(num) >= 0;
+		};
+		BN.prototype.ltn = function ltn(num) {
+			return this.cmpn(num) === -1;
+		};
+		BN.prototype.lt = function lt(num) {
+			return this.cmp(num) === -1;
+		};
+		BN.prototype.lten = function lten(num) {
+			return this.cmpn(num) <= 0;
+		};
+		BN.prototype.lte = function lte(num) {
+			return this.cmp(num) <= 0;
+		};
+		BN.prototype.eqn = function eqn(num) {
+			return this.cmpn(num) === 0;
+		};
+		BN.prototype.eq = function eq(num) {
+			return this.cmp(num) === 0;
+		};
+		BN.red = function red(num) {
+			return new Red(num);
+		};
+		BN.prototype.toRed = function toRed(ctx) {
+			assert(!this.red, "Already a number in reduction context");
+			assert(this.negative === 0, "red works only with positives");
+			return ctx.convertTo(this)._forceRed(ctx);
+		};
+		BN.prototype.fromRed = function fromRed() {
+			assert(this.red, "fromRed works only with numbers in reduction context");
+			return this.red.convertFrom(this);
+		};
+		BN.prototype._forceRed = function _forceRed(ctx) {
+			this.red = ctx;
+			return this;
+		};
+		BN.prototype.forceRed = function forceRed(ctx) {
+			assert(!this.red, "Already a number in reduction context");
+			return this._forceRed(ctx);
+		};
+		BN.prototype.redAdd = function redAdd(num) {
+			assert(this.red, "redAdd works only with red numbers");
+			return this.red.add(this, num);
+		};
+		BN.prototype.redIAdd = function redIAdd(num) {
+			assert(this.red, "redIAdd works only with red numbers");
+			return this.red.iadd(this, num);
+		};
+		BN.prototype.redSub = function redSub(num) {
+			assert(this.red, "redSub works only with red numbers");
+			return this.red.sub(this, num);
+		};
+		BN.prototype.redISub = function redISub(num) {
+			assert(this.red, "redISub works only with red numbers");
+			return this.red.isub(this, num);
+		};
+		BN.prototype.redShl = function redShl(num) {
+			assert(this.red, "redShl works only with red numbers");
+			return this.red.shl(this, num);
+		};
+		BN.prototype.redMul = function redMul(num) {
+			assert(this.red, "redMul works only with red numbers");
+			this.red._verify2(this, num);
+			return this.red.mul(this, num);
+		};
+		BN.prototype.redIMul = function redIMul(num) {
+			assert(this.red, "redMul works only with red numbers");
+			this.red._verify2(this, num);
+			return this.red.imul(this, num);
+		};
+		BN.prototype.redSqr = function redSqr() {
+			assert(this.red, "redSqr works only with red numbers");
+			this.red._verify1(this);
+			return this.red.sqr(this);
+		};
+		BN.prototype.redISqr = function redISqr() {
+			assert(this.red, "redISqr works only with red numbers");
+			this.red._verify1(this);
+			return this.red.isqr(this);
+		};
+		BN.prototype.redSqrt = function redSqrt() {
+			assert(this.red, "redSqrt works only with red numbers");
+			this.red._verify1(this);
+			return this.red.sqrt(this);
+		};
+		BN.prototype.redInvm = function redInvm() {
+			assert(this.red, "redInvm works only with red numbers");
+			this.red._verify1(this);
+			return this.red.invm(this);
+		};
+		BN.prototype.redNeg = function redNeg() {
+			assert(this.red, "redNeg works only with red numbers");
+			this.red._verify1(this);
+			return this.red.neg(this);
+		};
+		BN.prototype.redPow = function redPow(num) {
+			assert(this.red && !num.red, "redPow(normalNum)");
+			this.red._verify1(this);
+			return this.red.pow(this, num);
+		};
+		var primes = {
+			k256: null,
+			p224: null,
+			p192: null,
+			p25519: null
+		};
+		function MPrime(name, p) {
+			this.name = name;
+			this.p = new BN(p, 16);
+			this.n = this.p.bitLength();
+			this.k = new BN(1).iushln(this.n).isub(this.p);
+			this.tmp = this._tmp();
+		}
+		MPrime.prototype._tmp = function _tmp() {
+			var tmp = new BN(null);
+			tmp.words = new Array(Math.ceil(this.n / 13));
+			return tmp;
+		};
+		MPrime.prototype.ireduce = function ireduce(num) {
+			var r = num;
+			var rlen;
+			do {
+				this.split(r, this.tmp);
+				r = this.imulK(r);
+				r = r.iadd(this.tmp);
+				rlen = r.bitLength();
+			} while (rlen > this.n);
+			var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
+			if (cmp === 0) {
+				r.words[0] = 0;
+				r.length = 1;
+			} else if (cmp > 0) r.isub(this.p);
+			else if (r.strip !== void 0) r.strip();
+			else r._strip();
+			return r;
+		};
+		MPrime.prototype.split = function split(input, out) {
+			input.iushrn(this.n, 0, out);
+		};
+		MPrime.prototype.imulK = function imulK(num) {
+			return num.imul(this.k);
+		};
+		function K256() {
+			MPrime.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");
+		}
+		inherits(K256, MPrime);
+		K256.prototype.split = function split(input, output) {
+			var mask = 4194303;
+			var outLen = Math.min(input.length, 9);
+			for (var i = 0; i < outLen; i++) output.words[i] = input.words[i];
+			output.length = outLen;
+			if (input.length <= 9) {
+				input.words[0] = 0;
+				input.length = 1;
+				return;
+			}
+			var prev = input.words[9];
+			output.words[output.length++] = prev & mask;
+			for (i = 10; i < input.length; i++) {
+				var next = input.words[i] | 0;
+				input.words[i - 10] = (next & mask) << 4 | prev >>> 22;
+				prev = next;
+			}
+			prev >>>= 22;
+			input.words[i - 10] = prev;
+			if (prev === 0 && input.length > 10) input.length -= 10;
+			else input.length -= 9;
+		};
+		K256.prototype.imulK = function imulK(num) {
+			num.words[num.length] = 0;
+			num.words[num.length + 1] = 0;
+			num.length += 2;
+			var lo = 0;
+			for (var i = 0; i < num.length; i++) {
+				var w = num.words[i] | 0;
+				lo += w * 977;
+				num.words[i] = lo & 67108863;
+				lo = w * 64 + (lo / 67108864 | 0);
+			}
+			if (num.words[num.length - 1] === 0) {
+				num.length--;
+				if (num.words[num.length - 1] === 0) num.length--;
+			}
+			return num;
+		};
+		function P224() {
+			MPrime.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");
+		}
+		inherits(P224, MPrime);
+		function P192() {
+			MPrime.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");
+		}
+		inherits(P192, MPrime);
+		function P25519() {
+			MPrime.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");
+		}
+		inherits(P25519, MPrime);
+		P25519.prototype.imulK = function imulK(num) {
+			var carry = 0;
+			for (var i = 0; i < num.length; i++) {
+				var hi = (num.words[i] | 0) * 19 + carry;
+				var lo = hi & 67108863;
+				hi >>>= 26;
+				num.words[i] = lo;
+				carry = hi;
+			}
+			if (carry !== 0) num.words[num.length++] = carry;
+			return num;
+		};
+		BN._prime = function prime(name) {
+			if (primes[name]) return primes[name];
+			var prime;
+			if (name === "k256") prime = new K256();
+			else if (name === "p224") prime = new P224();
+			else if (name === "p192") prime = new P192();
+			else if (name === "p25519") prime = new P25519();
+			else throw new Error("Unknown prime " + name);
+			primes[name] = prime;
+			return prime;
+		};
+		function Red(m) {
+			if (typeof m === "string") {
+				var prime = BN._prime(m);
+				this.m = prime.p;
+				this.prime = prime;
+			} else {
+				assert(m.gtn(1), "modulus must be greater than 1");
+				this.m = m;
+				this.prime = null;
+			}
+		}
+		Red.prototype._verify1 = function _verify1(a) {
+			assert(a.negative === 0, "red works only with positives");
+			assert(a.red, "red works only with red numbers");
+		};
+		Red.prototype._verify2 = function _verify2(a, b) {
+			assert((a.negative | b.negative) === 0, "red works only with positives");
+			assert(a.red && a.red === b.red, "red works only with red numbers");
+		};
+		Red.prototype.imod = function imod(a) {
+			if (this.prime) return this.prime.ireduce(a)._forceRed(this);
+			move(a, a.umod(this.m)._forceRed(this));
+			return a;
+		};
+		Red.prototype.neg = function neg(a) {
+			if (a.isZero()) return a.clone();
+			return this.m.sub(a)._forceRed(this);
+		};
+		Red.prototype.add = function add(a, b) {
+			this._verify2(a, b);
+			var res = a.add(b);
+			if (res.cmp(this.m) >= 0) res.isub(this.m);
+			return res._forceRed(this);
+		};
+		Red.prototype.iadd = function iadd(a, b) {
+			this._verify2(a, b);
+			var res = a.iadd(b);
+			if (res.cmp(this.m) >= 0) res.isub(this.m);
+			return res;
+		};
+		Red.prototype.sub = function sub(a, b) {
+			this._verify2(a, b);
+			var res = a.sub(b);
+			if (res.cmpn(0) < 0) res.iadd(this.m);
+			return res._forceRed(this);
+		};
+		Red.prototype.isub = function isub(a, b) {
+			this._verify2(a, b);
+			var res = a.isub(b);
+			if (res.cmpn(0) < 0) res.iadd(this.m);
+			return res;
+		};
+		Red.prototype.shl = function shl(a, num) {
+			this._verify1(a);
+			return this.imod(a.ushln(num));
+		};
+		Red.prototype.imul = function imul(a, b) {
+			this._verify2(a, b);
+			return this.imod(a.imul(b));
+		};
+		Red.prototype.mul = function mul(a, b) {
+			this._verify2(a, b);
+			return this.imod(a.mul(b));
+		};
+		Red.prototype.isqr = function isqr(a) {
+			return this.imul(a, a.clone());
+		};
+		Red.prototype.sqr = function sqr(a) {
+			return this.mul(a, a);
+		};
+		Red.prototype.sqrt = function sqrt(a) {
+			if (a.isZero()) return a.clone();
+			var mod3 = this.m.andln(3);
+			assert(mod3 % 2 === 1);
+			if (mod3 === 3) {
+				var pow = this.m.add(new BN(1)).iushrn(2);
+				return this.pow(a, pow);
+			}
+			var q = this.m.subn(1);
+			var s = 0;
+			while (!q.isZero() && q.andln(1) === 0) {
+				s++;
+				q.iushrn(1);
+			}
+			assert(!q.isZero());
+			var one = new BN(1).toRed(this);
+			var nOne = one.redNeg();
+			var lpow = this.m.subn(1).iushrn(1);
+			var z = this.m.bitLength();
+			z = new BN(2 * z * z).toRed(this);
+			while (this.pow(z, lpow).cmp(nOne) !== 0) z.redIAdd(nOne);
+			var c = this.pow(z, q);
+			var r = this.pow(a, q.addn(1).iushrn(1));
+			var t = this.pow(a, q);
+			var m = s;
+			while (t.cmp(one) !== 0) {
+				var tmp = t;
+				for (var i = 0; tmp.cmp(one) !== 0; i++) tmp = tmp.redSqr();
+				assert(i < m);
+				var b = this.pow(c, new BN(1).iushln(m - i - 1));
+				r = r.redMul(b);
+				c = b.redSqr();
+				t = t.redMul(c);
+				m = i;
+			}
+			return r;
+		};
+		Red.prototype.invm = function invm(a) {
+			var inv = a._invmp(this.m);
+			if (inv.negative !== 0) {
+				inv.negative = 0;
+				return this.imod(inv).redNeg();
+			} else return this.imod(inv);
+		};
+		Red.prototype.pow = function pow(a, num) {
+			if (num.isZero()) return new BN(1).toRed(this);
+			if (num.cmpn(1) === 0) return a.clone();
+			var windowSize = 4;
+			var wnd = new Array(1 << windowSize);
+			wnd[0] = new BN(1).toRed(this);
+			wnd[1] = a;
+			for (var i = 2; i < wnd.length; i++) wnd[i] = this.mul(wnd[i - 1], a);
+			var res = wnd[0];
+			var current = 0;
+			var currentLen = 0;
+			var start = num.bitLength() % 26;
+			if (start === 0) start = 26;
+			for (i = num.length - 1; i >= 0; i--) {
+				var word = num.words[i];
+				for (var j = start - 1; j >= 0; j--) {
+					var bit = word >> j & 1;
+					if (res !== wnd[0]) res = this.sqr(res);
+					if (bit === 0 && current === 0) {
+						currentLen = 0;
+						continue;
+					}
+					current <<= 1;
+					current |= bit;
+					currentLen++;
+					if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;
+					res = this.mul(res, wnd[current]);
+					currentLen = 0;
+					current = 0;
+				}
+				start = 26;
+			}
+			return res;
+		};
+		Red.prototype.convertTo = function convertTo(num) {
+			var r = num.umod(this.m);
+			return r === num ? r.clone() : r;
+		};
+		Red.prototype.convertFrom = function convertFrom(num) {
+			var res = num.clone();
+			res.red = null;
+			return res;
+		};
+		BN.mont = function mont(num) {
+			return new Mont(num);
+		};
+		function Mont(m) {
+			Red.call(this, m);
+			this.shift = this.m.bitLength();
+			if (this.shift % 26 !== 0) this.shift += 26 - this.shift % 26;
+			this.r = new BN(1).iushln(this.shift);
+			this.r2 = this.imod(this.r.sqr());
+			this.rinv = this.r._invmp(this.m);
+			this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
+			this.minv = this.minv.umod(this.r);
+			this.minv = this.r.sub(this.minv);
+		}
+		inherits(Mont, Red);
+		Mont.prototype.convertTo = function convertTo(num) {
+			return this.imod(num.ushln(this.shift));
+		};
+		Mont.prototype.convertFrom = function convertFrom(num) {
+			var r = this.imod(num.mul(this.rinv));
+			r.red = null;
+			return r;
+		};
+		Mont.prototype.imul = function imul(a, b) {
+			if (a.isZero() || b.isZero()) {
+				a.words[0] = 0;
+				a.length = 1;
+				return a;
+			}
+			var t = a.imul(b);
+			var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+			var u = t.isub(c).iushrn(this.shift);
+			var res = u;
+			if (u.cmp(this.m) >= 0) res = u.isub(this.m);
+			else if (u.cmpn(0) < 0) res = u.iadd(this.m);
+			return res._forceRed(this);
+		};
+		Mont.prototype.mul = function mul(a, b) {
+			if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
+			var t = a.mul(b);
+			var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
+			var u = t.isub(c).iushrn(this.shift);
+			var res = u;
+			if (u.cmp(this.m) >= 0) res = u.isub(this.m);
+			else if (u.cmpn(0) < 0) res = u.iadd(this.m);
+			return res._forceRed(this);
+		};
+		Mont.prototype.invm = function invm(a) {
+			return this.imod(a._invmp(this.m).mul(this.r2))._forceRed(this);
+		};
+	})(typeof module === "undefined" || module, exports);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+bignumber@5.8.0/node_modules/@ethersproject/bignumber/lib/_version.js
+var require__version$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.version = void 0;
+	exports.version = "bignumber/5.8.0";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+bignumber@5.8.0/node_modules/@ethersproject/bignumber/lib/bignumber.js
+var require_bignumber = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __importDefault = exports && exports.__importDefault || function(mod) {
+		return mod && mod.__esModule ? mod : { "default": mod };
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports._base16To36 = exports._base36To16 = exports.BigNumber = exports.isBigNumberish = void 0;
+	var BN = __importDefault(require_bn()).default.BN;
+	var bytes_1 = require_lib$5();
+	var logger_1 = require_lib$6();
+	var _version_1 = require__version$3();
+	var logger = new logger_1.Logger(_version_1.version);
+	var _constructorGuard = {};
+	var MAX_SAFE = 9007199254740991;
+	function isBigNumberish(value) {
+		return value != null && (BigNumber.isBigNumber(value) || typeof value === "number" && value % 1 === 0 || typeof value === "string" && !!value.match(/^-?[0-9]+$/) || (0, bytes_1.isHexString)(value) || typeof value === "bigint" || (0, bytes_1.isBytes)(value));
+	}
+	exports.isBigNumberish = isBigNumberish;
+	var _warnedToStringRadix = false;
+	var BigNumber = function() {
+		function BigNumber(constructorGuard, hex) {
+			if (constructorGuard !== _constructorGuard) logger.throwError("cannot call constructor directly; use BigNumber.from", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "new (BigNumber)" });
+			this._hex = hex;
+			this._isBigNumber = true;
+			Object.freeze(this);
+		}
+		BigNumber.prototype.fromTwos = function(value) {
+			return toBigNumber(toBN(this).fromTwos(value));
+		};
+		BigNumber.prototype.toTwos = function(value) {
+			return toBigNumber(toBN(this).toTwos(value));
+		};
+		BigNumber.prototype.abs = function() {
+			if (this._hex[0] === "-") return BigNumber.from(this._hex.substring(1));
+			return this;
+		};
+		BigNumber.prototype.add = function(other) {
+			return toBigNumber(toBN(this).add(toBN(other)));
+		};
+		BigNumber.prototype.sub = function(other) {
+			return toBigNumber(toBN(this).sub(toBN(other)));
+		};
+		BigNumber.prototype.div = function(other) {
+			if (BigNumber.from(other).isZero()) throwFault("division-by-zero", "div");
+			return toBigNumber(toBN(this).div(toBN(other)));
+		};
+		BigNumber.prototype.mul = function(other) {
+			return toBigNumber(toBN(this).mul(toBN(other)));
+		};
+		BigNumber.prototype.mod = function(other) {
+			var value = toBN(other);
+			if (value.isNeg()) throwFault("division-by-zero", "mod");
+			return toBigNumber(toBN(this).umod(value));
+		};
+		BigNumber.prototype.pow = function(other) {
+			var value = toBN(other);
+			if (value.isNeg()) throwFault("negative-power", "pow");
+			return toBigNumber(toBN(this).pow(value));
+		};
+		BigNumber.prototype.and = function(other) {
+			var value = toBN(other);
+			if (this.isNegative() || value.isNeg()) throwFault("unbound-bitwise-result", "and");
+			return toBigNumber(toBN(this).and(value));
+		};
+		BigNumber.prototype.or = function(other) {
+			var value = toBN(other);
+			if (this.isNegative() || value.isNeg()) throwFault("unbound-bitwise-result", "or");
+			return toBigNumber(toBN(this).or(value));
+		};
+		BigNumber.prototype.xor = function(other) {
+			var value = toBN(other);
+			if (this.isNegative() || value.isNeg()) throwFault("unbound-bitwise-result", "xor");
+			return toBigNumber(toBN(this).xor(value));
+		};
+		BigNumber.prototype.mask = function(value) {
+			if (this.isNegative() || value < 0) throwFault("negative-width", "mask");
+			return toBigNumber(toBN(this).maskn(value));
+		};
+		BigNumber.prototype.shl = function(value) {
+			if (this.isNegative() || value < 0) throwFault("negative-width", "shl");
+			return toBigNumber(toBN(this).shln(value));
+		};
+		BigNumber.prototype.shr = function(value) {
+			if (this.isNegative() || value < 0) throwFault("negative-width", "shr");
+			return toBigNumber(toBN(this).shrn(value));
+		};
+		BigNumber.prototype.eq = function(other) {
+			return toBN(this).eq(toBN(other));
+		};
+		BigNumber.prototype.lt = function(other) {
+			return toBN(this).lt(toBN(other));
+		};
+		BigNumber.prototype.lte = function(other) {
+			return toBN(this).lte(toBN(other));
+		};
+		BigNumber.prototype.gt = function(other) {
+			return toBN(this).gt(toBN(other));
+		};
+		BigNumber.prototype.gte = function(other) {
+			return toBN(this).gte(toBN(other));
+		};
+		BigNumber.prototype.isNegative = function() {
+			return this._hex[0] === "-";
+		};
+		BigNumber.prototype.isZero = function() {
+			return toBN(this).isZero();
+		};
+		BigNumber.prototype.toNumber = function() {
+			try {
+				return toBN(this).toNumber();
+			} catch (error) {
+				throwFault("overflow", "toNumber", this.toString());
+			}
+			return null;
+		};
+		BigNumber.prototype.toBigInt = function() {
+			try {
+				return BigInt(this.toString());
+			} catch (e) {}
+			return logger.throwError("this platform does not support BigInt", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { value: this.toString() });
+		};
+		BigNumber.prototype.toString = function() {
+			if (arguments.length > 0) {
+				if (arguments[0] === 10) {
+					if (!_warnedToStringRadix) {
+						_warnedToStringRadix = true;
+						logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+					}
+				} else if (arguments[0] === 16) logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", logger_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
+				else logger.throwError("BigNumber.toString does not accept parameters", logger_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
+			}
+			return toBN(this).toString(10);
+		};
+		BigNumber.prototype.toHexString = function() {
+			return this._hex;
+		};
+		BigNumber.prototype.toJSON = function(key) {
+			return {
+				type: "BigNumber",
+				hex: this.toHexString()
+			};
+		};
+		BigNumber.from = function(value) {
+			if (value instanceof BigNumber) return value;
+			if (typeof value === "string") {
+				if (value.match(/^-?0x[0-9a-f]+$/i)) return new BigNumber(_constructorGuard, toHex(value));
+				if (value.match(/^-?[0-9]+$/)) return new BigNumber(_constructorGuard, toHex(new BN(value)));
+				return logger.throwArgumentError("invalid BigNumber string", "value", value);
+			}
+			if (typeof value === "number") {
+				if (value % 1) throwFault("underflow", "BigNumber.from", value);
+				if (value >= MAX_SAFE || value <= -MAX_SAFE) throwFault("overflow", "BigNumber.from", value);
+				return BigNumber.from(String(value));
+			}
+			var anyValue = value;
+			if (typeof anyValue === "bigint") return BigNumber.from(anyValue.toString());
+			if ((0, bytes_1.isBytes)(anyValue)) return BigNumber.from((0, bytes_1.hexlify)(anyValue));
+			if (anyValue) {
+				if (anyValue.toHexString) {
+					var hex = anyValue.toHexString();
+					if (typeof hex === "string") return BigNumber.from(hex);
+				} else {
+					var hex = anyValue._hex;
+					if (hex == null && anyValue.type === "BigNumber") hex = anyValue.hex;
+					if (typeof hex === "string") {
+						if ((0, bytes_1.isHexString)(hex) || hex[0] === "-" && (0, bytes_1.isHexString)(hex.substring(1))) return BigNumber.from(hex);
+					}
+				}
+			}
+			return logger.throwArgumentError("invalid BigNumber value", "value", value);
+		};
+		BigNumber.isBigNumber = function(value) {
+			return !!(value && value._isBigNumber);
+		};
+		return BigNumber;
+	}();
+	exports.BigNumber = BigNumber;
+	function toHex(value) {
+		if (typeof value !== "string") return toHex(value.toString(16));
+		if (value[0] === "-") {
+			value = value.substring(1);
+			if (value[0] === "-") logger.throwArgumentError("invalid hex", "value", value);
+			value = toHex(value);
+			if (value === "0x00") return value;
+			return "-" + value;
+		}
+		if (value.substring(0, 2) !== "0x") value = "0x" + value;
+		if (value === "0x") return "0x00";
+		if (value.length % 2) value = "0x0" + value.substring(2);
+		while (value.length > 4 && value.substring(0, 4) === "0x00") value = "0x" + value.substring(4);
+		return value;
+	}
+	function toBigNumber(value) {
+		return BigNumber.from(toHex(value));
+	}
+	function toBN(value) {
+		var hex = BigNumber.from(value).toHexString();
+		if (hex[0] === "-") return new BN("-" + hex.substring(3), 16);
+		return new BN(hex.substring(2), 16);
+	}
+	function throwFault(fault, operation, value) {
+		var params = {
+			fault,
+			operation
+		};
+		if (value != null) params.value = value;
+		return logger.throwError(fault, logger_1.Logger.errors.NUMERIC_FAULT, params);
+	}
+	function _base36To16(value) {
+		return new BN(value, 36).toString(16);
+	}
+	exports._base36To16 = _base36To16;
+	function _base16To36(value) {
+		return new BN(value, 16).toString(36);
+	}
+	exports._base16To36 = _base16To36;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+bignumber@5.8.0/node_modules/@ethersproject/bignumber/lib/fixednumber.js
+var require_fixednumber = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.FixedNumber = exports.FixedFormat = exports.parseFixed = exports.formatFixed = void 0;
+	var bytes_1 = require_lib$5();
+	var logger_1 = require_lib$6();
+	var _version_1 = require__version$3();
+	var logger = new logger_1.Logger(_version_1.version);
+	var bignumber_1 = require_bignumber();
+	var _constructorGuard = {};
+	var Zero = bignumber_1.BigNumber.from(0);
+	var NegativeOne = bignumber_1.BigNumber.from(-1);
+	function throwFault(message, fault, operation, value) {
+		var params = {
+			fault,
+			operation
+		};
+		if (value !== void 0) params.value = value;
+		return logger.throwError(message, logger_1.Logger.errors.NUMERIC_FAULT, params);
+	}
+	var zeros = "0";
+	while (zeros.length < 256) zeros += zeros;
+	function getMultiplier(decimals) {
+		if (typeof decimals !== "number") try {
+			decimals = bignumber_1.BigNumber.from(decimals).toNumber();
+		} catch (e) {}
+		if (typeof decimals === "number" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) return "1" + zeros.substring(0, decimals);
+		return logger.throwArgumentError("invalid decimal size", "decimals", decimals);
+	}
+	function formatFixed(value, decimals) {
+		if (decimals == null) decimals = 0;
+		var multiplier = getMultiplier(decimals);
+		value = bignumber_1.BigNumber.from(value);
+		var negative = value.lt(Zero);
+		if (negative) value = value.mul(NegativeOne);
+		var fraction = value.mod(multiplier).toString();
+		while (fraction.length < multiplier.length - 1) fraction = "0" + fraction;
+		fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
+		var whole = value.div(multiplier).toString();
+		if (multiplier.length === 1) value = whole;
+		else value = whole + "." + fraction;
+		if (negative) value = "-" + value;
+		return value;
+	}
+	exports.formatFixed = formatFixed;
+	function parseFixed(value, decimals) {
+		if (decimals == null) decimals = 0;
+		var multiplier = getMultiplier(decimals);
+		if (typeof value !== "string" || !value.match(/^-?[0-9.]+$/)) logger.throwArgumentError("invalid decimal value", "value", value);
+		var negative = value.substring(0, 1) === "-";
+		if (negative) value = value.substring(1);
+		if (value === ".") logger.throwArgumentError("missing value", "value", value);
+		var comps = value.split(".");
+		if (comps.length > 2) logger.throwArgumentError("too many decimal points", "value", value);
+		var whole = comps[0], fraction = comps[1];
+		if (!whole) whole = "0";
+		if (!fraction) fraction = "0";
+		while (fraction[fraction.length - 1] === "0") fraction = fraction.substring(0, fraction.length - 1);
+		if (fraction.length > multiplier.length - 1) throwFault("fractional component exceeds decimals", "underflow", "parseFixed");
+		if (fraction === "") fraction = "0";
+		while (fraction.length < multiplier.length - 1) fraction += "0";
+		var wholeValue = bignumber_1.BigNumber.from(whole);
+		var fractionValue = bignumber_1.BigNumber.from(fraction);
+		var wei = wholeValue.mul(multiplier).add(fractionValue);
+		if (negative) wei = wei.mul(NegativeOne);
+		return wei;
+	}
+	exports.parseFixed = parseFixed;
+	var FixedFormat = function() {
+		function FixedFormat(constructorGuard, signed, width, decimals) {
+			if (constructorGuard !== _constructorGuard) logger.throwError("cannot use FixedFormat constructor; use FixedFormat.from", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "new FixedFormat" });
+			this.signed = signed;
+			this.width = width;
+			this.decimals = decimals;
+			this.name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
+			this._multiplier = getMultiplier(decimals);
+			Object.freeze(this);
+		}
+		FixedFormat.from = function(value) {
+			if (value instanceof FixedFormat) return value;
+			if (typeof value === "number") value = "fixed128x" + value;
+			var signed = true;
+			var width = 128;
+			var decimals = 18;
+			if (typeof value === "string") {
+				if (value === "fixed") {} else if (value === "ufixed") signed = false;
+				else {
+					var match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
+					if (!match) logger.throwArgumentError("invalid fixed format", "format", value);
+					signed = match[1] !== "u";
+					width = parseInt(match[2]);
+					decimals = parseInt(match[3]);
+				}
+			} else if (value) {
+				var check = function(key, type, defaultValue) {
+					if (value[key] == null) return defaultValue;
+					if (typeof value[key] !== type) logger.throwArgumentError("invalid fixed format (" + key + " not " + type + ")", "format." + key, value[key]);
+					return value[key];
+				};
+				signed = check("signed", "boolean", signed);
+				width = check("width", "number", width);
+				decimals = check("decimals", "number", decimals);
+			}
+			if (width % 8) logger.throwArgumentError("invalid fixed format width (not byte aligned)", "format.width", width);
+			if (decimals > 80) logger.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
+			return new FixedFormat(_constructorGuard, signed, width, decimals);
+		};
+		return FixedFormat;
+	}();
+	exports.FixedFormat = FixedFormat;
+	var FixedNumber = function() {
+		function FixedNumber(constructorGuard, hex, value, format) {
+			if (constructorGuard !== _constructorGuard) logger.throwError("cannot use FixedNumber constructor; use FixedNumber.from", logger_1.Logger.errors.UNSUPPORTED_OPERATION, { operation: "new FixedFormat" });
+			this.format = format;
+			this._hex = hex;
+			this._value = value;
+			this._isFixedNumber = true;
+			Object.freeze(this);
+		}
+		FixedNumber.prototype._checkFormat = function(other) {
+			if (this.format.name !== other.format.name) logger.throwArgumentError("incompatible format; use fixedNumber.toFormat", "other", other);
+		};
+		FixedNumber.prototype.addUnsafe = function(other) {
+			this._checkFormat(other);
+			var a = parseFixed(this._value, this.format.decimals);
+			var b = parseFixed(other._value, other.format.decimals);
+			return FixedNumber.fromValue(a.add(b), this.format.decimals, this.format);
+		};
+		FixedNumber.prototype.subUnsafe = function(other) {
+			this._checkFormat(other);
+			var a = parseFixed(this._value, this.format.decimals);
+			var b = parseFixed(other._value, other.format.decimals);
+			return FixedNumber.fromValue(a.sub(b), this.format.decimals, this.format);
+		};
+		FixedNumber.prototype.mulUnsafe = function(other) {
+			this._checkFormat(other);
+			var a = parseFixed(this._value, this.format.decimals);
+			var b = parseFixed(other._value, other.format.decimals);
+			return FixedNumber.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
+		};
+		FixedNumber.prototype.divUnsafe = function(other) {
+			this._checkFormat(other);
+			var a = parseFixed(this._value, this.format.decimals);
+			var b = parseFixed(other._value, other.format.decimals);
+			return FixedNumber.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
+		};
+		FixedNumber.prototype.floor = function() {
+			var comps = this.toString().split(".");
+			if (comps.length === 1) comps.push("0");
+			var result = FixedNumber.from(comps[0], this.format);
+			var hasFraction = !comps[1].match(/^(0*)$/);
+			if (this.isNegative() && hasFraction) result = result.subUnsafe(ONE.toFormat(result.format));
+			return result;
+		};
+		FixedNumber.prototype.ceiling = function() {
+			var comps = this.toString().split(".");
+			if (comps.length === 1) comps.push("0");
+			var result = FixedNumber.from(comps[0], this.format);
+			var hasFraction = !comps[1].match(/^(0*)$/);
+			if (!this.isNegative() && hasFraction) result = result.addUnsafe(ONE.toFormat(result.format));
+			return result;
+		};
+		FixedNumber.prototype.round = function(decimals) {
+			if (decimals == null) decimals = 0;
+			var comps = this.toString().split(".");
+			if (comps.length === 1) comps.push("0");
+			if (decimals < 0 || decimals > 80 || decimals % 1) logger.throwArgumentError("invalid decimal count", "decimals", decimals);
+			if (comps[1].length <= decimals) return this;
+			var factor = FixedNumber.from("1" + zeros.substring(0, decimals), this.format);
+			var bump = BUMP.toFormat(this.format);
+			return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);
+		};
+		FixedNumber.prototype.isZero = function() {
+			return this._value === "0.0" || this._value === "0";
+		};
+		FixedNumber.prototype.isNegative = function() {
+			return this._value[0] === "-";
+		};
+		FixedNumber.prototype.toString = function() {
+			return this._value;
+		};
+		FixedNumber.prototype.toHexString = function(width) {
+			if (width == null) return this._hex;
+			if (width % 8) logger.throwArgumentError("invalid byte width", "width", width);
+			var hex = bignumber_1.BigNumber.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();
+			return (0, bytes_1.hexZeroPad)(hex, width / 8);
+		};
+		FixedNumber.prototype.toUnsafeFloat = function() {
+			return parseFloat(this.toString());
+		};
+		FixedNumber.prototype.toFormat = function(format) {
+			return FixedNumber.fromString(this._value, format);
+		};
+		FixedNumber.fromValue = function(value, decimals, format) {
+			if (format == null && decimals != null && !(0, bignumber_1.isBigNumberish)(decimals)) {
+				format = decimals;
+				decimals = null;
+			}
+			if (decimals == null) decimals = 0;
+			if (format == null) format = "fixed";
+			return FixedNumber.fromString(formatFixed(value, decimals), FixedFormat.from(format));
+		};
+		FixedNumber.fromString = function(value, format) {
+			if (format == null) format = "fixed";
+			var fixedFormat = FixedFormat.from(format);
+			var numeric = parseFixed(value, fixedFormat.decimals);
+			if (!fixedFormat.signed && numeric.lt(Zero)) throwFault("unsigned value cannot be negative", "overflow", "value", value);
+			var hex = null;
+			if (fixedFormat.signed) hex = numeric.toTwos(fixedFormat.width).toHexString();
+			else {
+				hex = numeric.toHexString();
+				hex = (0, bytes_1.hexZeroPad)(hex, fixedFormat.width / 8);
+			}
+			var decimal = formatFixed(numeric, fixedFormat.decimals);
+			return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat);
+		};
+		FixedNumber.fromBytes = function(value, format) {
+			if (format == null) format = "fixed";
+			var fixedFormat = FixedFormat.from(format);
+			if ((0, bytes_1.arrayify)(value).length > fixedFormat.width / 8) throw new Error("overflow");
+			var numeric = bignumber_1.BigNumber.from(value);
+			if (fixedFormat.signed) numeric = numeric.fromTwos(fixedFormat.width);
+			return new FixedNumber(_constructorGuard, numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString(), formatFixed(numeric, fixedFormat.decimals), fixedFormat);
+		};
+		FixedNumber.from = function(value, format) {
+			if (typeof value === "string") return FixedNumber.fromString(value, format);
+			if ((0, bytes_1.isBytes)(value)) return FixedNumber.fromBytes(value, format);
+			try {
+				return FixedNumber.fromValue(value, 0, format);
+			} catch (error) {
+				if (error.code !== logger_1.Logger.errors.INVALID_ARGUMENT) throw error;
+			}
+			return logger.throwArgumentError("invalid FixedNumber value", "value", value);
+		};
+		FixedNumber.isFixedNumber = function(value) {
+			return !!(value && value._isFixedNumber);
+		};
+		return FixedNumber;
+	}();
+	exports.FixedNumber = FixedNumber;
+	var ONE = FixedNumber.from(1);
+	var BUMP = FixedNumber.from("0.5");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+bignumber@5.8.0/node_modules/@ethersproject/bignumber/lib/index.js
+var require_lib$4 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports._base36To16 = exports._base16To36 = exports.parseFixed = exports.FixedNumber = exports.FixedFormat = exports.formatFixed = exports.BigNumber = void 0;
+	var bignumber_1 = require_bignumber();
+	Object.defineProperty(exports, "BigNumber", {
+		enumerable: true,
+		get: function() {
+			return bignumber_1.BigNumber;
+		}
+	});
+	var fixednumber_1 = require_fixednumber();
+	Object.defineProperty(exports, "formatFixed", {
+		enumerable: true,
+		get: function() {
+			return fixednumber_1.formatFixed;
+		}
+	});
+	Object.defineProperty(exports, "FixedFormat", {
+		enumerable: true,
+		get: function() {
+			return fixednumber_1.FixedFormat;
+		}
+	});
+	Object.defineProperty(exports, "FixedNumber", {
+		enumerable: true,
+		get: function() {
+			return fixednumber_1.FixedNumber;
+		}
+	});
+	Object.defineProperty(exports, "parseFixed", {
+		enumerable: true,
+		get: function() {
+			return fixednumber_1.parseFixed;
+		}
+	});
+	var bignumber_2 = require_bignumber();
+	Object.defineProperty(exports, "_base16To36", {
+		enumerable: true,
+		get: function() {
+			return bignumber_2._base16To36;
+		}
+	});
+	Object.defineProperty(exports, "_base36To16", {
+		enumerable: true,
+		get: function() {
+			return bignumber_2._base36To16;
+		}
+	});
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+properties@5.8.0/node_modules/@ethersproject/properties/lib/_version.js
+var require__version$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.version = void 0;
+	exports.version = "properties/5.8.0";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+properties@5.8.0/node_modules/@ethersproject/properties/lib/index.js
+var require_lib$3 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+		function adopt(value) {
+			return value instanceof P ? value : new P(function(resolve) {
+				resolve(value);
+			});
+		}
+		return new (P || (P = Promise))(function(resolve, reject) {
+			function fulfilled(value) {
+				try {
+					step(generator.next(value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function rejected(value) {
+				try {
+					step(generator["throw"](value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function step(result) {
+				result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+			}
+			step((generator = generator.apply(thisArg, _arguments || [])).next());
+		});
+	};
+	var __generator = exports && exports.__generator || function(thisArg, body) {
+		var _ = {
+			label: 0,
+			sent: function() {
+				if (t[0] & 1) throw t[1];
+				return t[1];
+			},
+			trys: [],
+			ops: []
+		}, f, y, t, g;
+		return g = {
+			next: verb(0),
+			"throw": verb(1),
+			"return": verb(2)
+		}, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+			return this;
+		}), g;
+		function verb(n) {
+			return function(v) {
+				return step([n, v]);
+			};
+		}
+		function step(op) {
+			if (f) throw new TypeError("Generator is already executing.");
+			while (_) try {
+				if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+				if (y = 0, t) op = [op[0] & 2, t.value];
+				switch (op[0]) {
+					case 0:
+					case 1:
+						t = op;
+						break;
+					case 4:
+						_.label++;
+						return {
+							value: op[1],
+							done: false
+						};
+					case 5:
+						_.label++;
+						y = op[1];
+						op = [0];
+						continue;
+					case 7:
+						op = _.ops.pop();
+						_.trys.pop();
+						continue;
+					default:
+						if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+							_ = 0;
+							continue;
+						}
+						if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+							_.label = op[1];
+							break;
+						}
+						if (op[0] === 6 && _.label < t[1]) {
+							_.label = t[1];
+							t = op;
+							break;
+						}
+						if (t && _.label < t[2]) {
+							_.label = t[2];
+							_.ops.push(op);
+							break;
+						}
+						if (t[2]) _.ops.pop();
+						_.trys.pop();
+						continue;
+				}
+				op = body.call(thisArg, _);
+			} catch (e) {
+				op = [6, e];
+				y = 0;
+			} finally {
+				f = t = 0;
+			}
+			if (op[0] & 5) throw op[1];
+			return {
+				value: op[0] ? op[1] : void 0,
+				done: true
+			};
+		}
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Description = exports.deepCopy = exports.shallowCopy = exports.checkProperties = exports.resolveProperties = exports.getStatic = exports.defineReadOnly = void 0;
+	var logger_1 = require_lib$6();
+	var _version_1 = require__version$2();
+	var logger = new logger_1.Logger(_version_1.version);
+	function defineReadOnly(object, name, value) {
+		Object.defineProperty(object, name, {
+			enumerable: true,
+			value,
+			writable: false
+		});
+	}
+	exports.defineReadOnly = defineReadOnly;
+	function getStatic(ctor, key) {
+		for (var i = 0; i < 32; i++) {
+			if (ctor[key]) return ctor[key];
+			if (!ctor.prototype || typeof ctor.prototype !== "object") break;
+			ctor = Object.getPrototypeOf(ctor.prototype).constructor;
+		}
+		return null;
+	}
+	exports.getStatic = getStatic;
+	function resolveProperties(object) {
+		return __awaiter(this, void 0, void 0, function() {
+			var promises, results;
+			return __generator(this, function(_a) {
+				switch (_a.label) {
+					case 0:
+						promises = Object.keys(object).map(function(key) {
+							var value = object[key];
+							return Promise.resolve(value).then(function(v) {
+								return {
+									key,
+									value: v
+								};
+							});
+						});
+						return [4, Promise.all(promises)];
+					case 1:
+						results = _a.sent();
+						return [2, results.reduce(function(accum, result) {
+							accum[result.key] = result.value;
+							return accum;
+						}, {})];
+				}
+			});
+		});
+	}
+	exports.resolveProperties = resolveProperties;
+	function checkProperties(object, properties) {
+		if (!object || typeof object !== "object") logger.throwArgumentError("invalid object", "object", object);
+		Object.keys(object).forEach(function(key) {
+			if (!properties[key]) logger.throwArgumentError("invalid object key - " + key, "transaction:" + key, object);
+		});
+	}
+	exports.checkProperties = checkProperties;
+	function shallowCopy(object) {
+		var result = {};
+		for (var key in object) result[key] = object[key];
+		return result;
+	}
+	exports.shallowCopy = shallowCopy;
+	var opaque = {
+		bigint: true,
+		boolean: true,
+		"function": true,
+		number: true,
+		string: true
+	};
+	function _isFrozen(object) {
+		if (object === void 0 || object === null || opaque[typeof object]) return true;
+		if (Array.isArray(object) || typeof object === "object") {
+			if (!Object.isFrozen(object)) return false;
+			var keys = Object.keys(object);
+			for (var i = 0; i < keys.length; i++) {
+				var value = null;
+				try {
+					value = object[keys[i]];
+				} catch (error) {
+					continue;
+				}
+				if (!_isFrozen(value)) return false;
+			}
+			return true;
+		}
+		return logger.throwArgumentError("Cannot deepCopy " + typeof object, "object", object);
+	}
+	function _deepCopy(object) {
+		if (_isFrozen(object)) return object;
+		if (Array.isArray(object)) return Object.freeze(object.map(function(item) {
+			return deepCopy(item);
+		}));
+		if (typeof object === "object") {
+			var result = {};
+			for (var key in object) {
+				var value = object[key];
+				if (value === void 0) continue;
+				defineReadOnly(result, key, deepCopy(value));
+			}
+			return result;
+		}
+		return logger.throwArgumentError("Cannot deepCopy " + typeof object, "object", object);
+	}
+	function deepCopy(object) {
+		return _deepCopy(object);
+	}
+	exports.deepCopy = deepCopy;
+	exports.Description = function() {
+		function Description(info) {
+			for (var key in info) this[key] = deepCopy(info[key]);
+		}
+		return Description;
+	}();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+rlp@5.8.0/node_modules/@ethersproject/rlp/lib/_version.js
+var require__version$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.version = void 0;
+	exports.version = "rlp/5.8.0";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+rlp@5.8.0/node_modules/@ethersproject/rlp/lib/index.js
+var require_lib$2 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.decode = exports.encode = void 0;
+	var bytes_1 = require_lib$5();
+	var logger_1 = require_lib$6();
+	var _version_1 = require__version$1();
+	var logger = new logger_1.Logger(_version_1.version);
+	function arrayifyInteger(value) {
+		var result = [];
+		while (value) {
+			result.unshift(value & 255);
+			value >>= 8;
+		}
+		return result;
+	}
+	function unarrayifyInteger(data, offset, length) {
+		var result = 0;
+		for (var i = 0; i < length; i++) result = result * 256 + data[offset + i];
+		return result;
+	}
+	function _encode(object) {
+		if (Array.isArray(object)) {
+			var payload_1 = [];
+			object.forEach(function(child) {
+				payload_1 = payload_1.concat(_encode(child));
+			});
+			if (payload_1.length <= 55) {
+				payload_1.unshift(192 + payload_1.length);
+				return payload_1;
+			}
+			var length_1 = arrayifyInteger(payload_1.length);
+			length_1.unshift(247 + length_1.length);
+			return length_1.concat(payload_1);
+		}
+		if (!(0, bytes_1.isBytesLike)(object)) logger.throwArgumentError("RLP object must be BytesLike", "object", object);
+		var data = Array.prototype.slice.call((0, bytes_1.arrayify)(object));
+		if (data.length === 1 && data[0] <= 127) return data;
+		else if (data.length <= 55) {
+			data.unshift(128 + data.length);
+			return data;
+		}
+		var length = arrayifyInteger(data.length);
+		length.unshift(183 + length.length);
+		return length.concat(data);
+	}
+	function encode(object) {
+		return (0, bytes_1.hexlify)(_encode(object));
+	}
+	exports.encode = encode;
+	function _decodeChildren(data, offset, childOffset, length) {
+		var result = [];
+		while (childOffset < offset + 1 + length) {
+			var decoded = _decode(data, childOffset);
+			result.push(decoded.result);
+			childOffset += decoded.consumed;
+			if (childOffset > offset + 1 + length) logger.throwError("child data too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+		}
+		return {
+			consumed: 1 + length,
+			result
+		};
+	}
+	function _decode(data, offset) {
+		if (data.length === 0) logger.throwError("data too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+		if (data[offset] >= 248) {
+			var lengthLength = data[offset] - 247;
+			if (offset + 1 + lengthLength > data.length) logger.throwError("data short segment too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			var length_2 = unarrayifyInteger(data, offset + 1, lengthLength);
+			if (offset + 1 + lengthLength + length_2 > data.length) logger.throwError("data long segment too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length_2);
+		} else if (data[offset] >= 192) {
+			var length_3 = data[offset] - 192;
+			if (offset + 1 + length_3 > data.length) logger.throwError("data array too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			return _decodeChildren(data, offset, offset + 1, length_3);
+		} else if (data[offset] >= 184) {
+			var lengthLength = data[offset] - 183;
+			if (offset + 1 + lengthLength > data.length) logger.throwError("data array too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			var length_4 = unarrayifyInteger(data, offset + 1, lengthLength);
+			if (offset + 1 + lengthLength + length_4 > data.length) logger.throwError("data array too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			var result = (0, bytes_1.hexlify)(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length_4));
+			return {
+				consumed: 1 + lengthLength + length_4,
+				result
+			};
+		} else if (data[offset] >= 128) {
+			var length_5 = data[offset] - 128;
+			if (offset + 1 + length_5 > data.length) logger.throwError("data too short", logger_1.Logger.errors.BUFFER_OVERRUN, {});
+			var result = (0, bytes_1.hexlify)(data.slice(offset + 1, offset + 1 + length_5));
+			return {
+				consumed: 1 + length_5,
+				result
+			};
+		}
+		return {
+			consumed: 1,
+			result: (0, bytes_1.hexlify)(data[offset])
+		};
+	}
+	function decode(data) {
+		var bytes = (0, bytes_1.arrayify)(data);
+		var decoded = _decode(bytes, 0);
+		if (decoded.consumed !== bytes.length) logger.throwArgumentError("invalid rlp data", "data", data);
+		return decoded.result;
+	}
+	exports.decode = decode;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+address@5.8.0/node_modules/@ethersproject/address/lib/_version.js
+var require__version = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.version = void 0;
+	exports.version = "address/5.8.0";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+address@5.8.0/node_modules/@ethersproject/address/lib/index.js
+var require_lib$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getCreate2Address = exports.getContractAddress = exports.getIcapAddress = exports.isAddress = exports.getAddress = void 0;
+	var bytes_1 = require_lib$5();
+	var bignumber_1 = require_lib$4();
+	var keccak256_1 = require_lib$7();
+	var rlp_1 = require_lib$2();
+	var logger_1 = require_lib$6();
+	var _version_1 = require__version();
+	var logger = new logger_1.Logger(_version_1.version);
+	function getChecksumAddress(address) {
+		if (!(0, bytes_1.isHexString)(address, 20)) logger.throwArgumentError("invalid address", "address", address);
+		address = address.toLowerCase();
+		var chars = address.substring(2).split("");
+		var expanded = /* @__PURE__ */ new Uint8Array(40);
+		for (var i = 0; i < 40; i++) expanded[i] = chars[i].charCodeAt(0);
+		var hashed = (0, bytes_1.arrayify)((0, keccak256_1.keccak256)(expanded));
+		for (var i = 0; i < 40; i += 2) {
+			if (hashed[i >> 1] >> 4 >= 8) chars[i] = chars[i].toUpperCase();
+			if ((hashed[i >> 1] & 15) >= 8) chars[i + 1] = chars[i + 1].toUpperCase();
+		}
+		return "0x" + chars.join("");
+	}
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	function log10(x) {
+		if (Math.log10) return Math.log10(x);
+		return Math.log(x) / Math.LN10;
+	}
+	var ibanLookup = {};
+	for (var i = 0; i < 10; i++) ibanLookup[String(i)] = String(i);
+	for (var i = 0; i < 26; i++) ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
+	var safeDigits = Math.floor(log10(MAX_SAFE_INTEGER));
+	function ibanChecksum(address) {
+		address = address.toUpperCase();
+		address = address.substring(4) + address.substring(0, 2) + "00";
+		var expanded = address.split("").map(function(c) {
+			return ibanLookup[c];
+		}).join("");
+		while (expanded.length >= safeDigits) {
+			var block = expanded.substring(0, safeDigits);
+			expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
+		}
+		var checksum = String(98 - parseInt(expanded, 10) % 97);
+		while (checksum.length < 2) checksum = "0" + checksum;
+		return checksum;
+	}
+	function getAddress(address) {
+		var result = null;
+		if (typeof address !== "string") logger.throwArgumentError("invalid address", "address", address);
+		if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
+			if (address.substring(0, 2) !== "0x") address = "0x" + address;
+			result = getChecksumAddress(address);
+			if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) logger.throwArgumentError("bad address checksum", "address", address);
+		} else if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
+			if (address.substring(2, 4) !== ibanChecksum(address)) logger.throwArgumentError("bad icap checksum", "address", address);
+			result = (0, bignumber_1._base36To16)(address.substring(4));
+			while (result.length < 40) result = "0" + result;
+			result = getChecksumAddress("0x" + result);
+		} else logger.throwArgumentError("invalid address", "address", address);
+		return result;
+	}
+	exports.getAddress = getAddress;
+	function isAddress(address) {
+		try {
+			getAddress(address);
+			return true;
+		} catch (error) {}
+		return false;
+	}
+	exports.isAddress = isAddress;
+	function getIcapAddress(address) {
+		var base36 = (0, bignumber_1._base16To36)(getAddress(address).substring(2)).toUpperCase();
+		while (base36.length < 30) base36 = "0" + base36;
+		return "XE" + ibanChecksum("XE00" + base36) + base36;
+	}
+	exports.getIcapAddress = getIcapAddress;
+	function getContractAddress(transaction) {
+		var from = null;
+		try {
+			from = getAddress(transaction.from);
+		} catch (error) {
+			logger.throwArgumentError("missing from address", "transaction", transaction);
+		}
+		var nonce = (0, bytes_1.stripZeros)((0, bytes_1.arrayify)(bignumber_1.BigNumber.from(transaction.nonce).toHexString()));
+		return getAddress((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, rlp_1.encode)([from, nonce])), 12));
+	}
+	exports.getContractAddress = getContractAddress;
+	function getCreate2Address(from, salt, initCodeHash) {
+		if ((0, bytes_1.hexDataLength)(salt) !== 32) logger.throwArgumentError("salt must be 32 bytes", "salt", salt);
+		if ((0, bytes_1.hexDataLength)(initCodeHash) !== 32) logger.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", initCodeHash);
+		return getAddress((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.concat)([
+			"0xff",
+			getAddress(from),
+			salt,
+			initCodeHash
+		])), 12));
+	}
+	exports.getCreate2Address = getCreate2Address;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+constants@5.8.0/node_modules/@ethersproject/constants/lib/addresses.js
+var require_addresses = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AddressZero = void 0;
+	exports.AddressZero = "0x0000000000000000000000000000000000000000";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+constants@5.8.0/node_modules/@ethersproject/constants/lib/bignumbers.js
+var require_bignumbers = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.MaxInt256 = exports.MinInt256 = exports.MaxUint256 = exports.WeiPerEther = exports.Two = exports.One = exports.Zero = exports.NegativeOne = void 0;
+	var bignumber_1 = require_lib$4();
+	exports.NegativeOne = /* @__PURE__ */ bignumber_1.BigNumber.from(-1);
+	exports.Zero = /* @__PURE__ */ bignumber_1.BigNumber.from(0);
+	exports.One = /* @__PURE__ */ bignumber_1.BigNumber.from(1);
+	exports.Two = /* @__PURE__ */ bignumber_1.BigNumber.from(2);
+	exports.WeiPerEther = /* @__PURE__ */ bignumber_1.BigNumber.from("1000000000000000000");
+	exports.MaxUint256 = /* @__PURE__ */ bignumber_1.BigNumber.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+	exports.MinInt256 = /* @__PURE__ */ bignumber_1.BigNumber.from("-0x8000000000000000000000000000000000000000000000000000000000000000");
+	exports.MaxInt256 = /* @__PURE__ */ bignumber_1.BigNumber.from("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+constants@5.8.0/node_modules/@ethersproject/constants/lib/hashes.js
+var require_hashes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HashZero = void 0;
+	exports.HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+constants@5.8.0/node_modules/@ethersproject/constants/lib/strings.js
+var require_strings = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.EtherSymbol = void 0;
+	exports.EtherSymbol = "Ξ";
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@ethersproject+constants@5.8.0/node_modules/@ethersproject/constants/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.EtherSymbol = exports.HashZero = exports.MaxInt256 = exports.MinInt256 = exports.MaxUint256 = exports.WeiPerEther = exports.Two = exports.One = exports.Zero = exports.NegativeOne = exports.AddressZero = void 0;
+	var addresses_1 = require_addresses();
+	Object.defineProperty(exports, "AddressZero", {
+		enumerable: true,
+		get: function() {
+			return addresses_1.AddressZero;
+		}
+	});
+	var bignumbers_1 = require_bignumbers();
+	Object.defineProperty(exports, "NegativeOne", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.NegativeOne;
+		}
+	});
+	Object.defineProperty(exports, "Zero", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.Zero;
+		}
+	});
+	Object.defineProperty(exports, "One", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.One;
+		}
+	});
+	Object.defineProperty(exports, "Two", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.Two;
+		}
+	});
+	Object.defineProperty(exports, "WeiPerEther", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.WeiPerEther;
+		}
+	});
+	Object.defineProperty(exports, "MaxUint256", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.MaxUint256;
+		}
+	});
+	Object.defineProperty(exports, "MinInt256", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.MinInt256;
+		}
+	});
+	Object.defineProperty(exports, "MaxInt256", {
+		enumerable: true,
+		get: function() {
+			return bignumbers_1.MaxInt256;
+		}
+	});
+	var hashes_1 = require_hashes();
+	Object.defineProperty(exports, "HashZero", {
+		enumerable: true,
+		get: function() {
+			return hashes_1.HashZero;
+		}
+	});
+	var strings_1 = require_strings();
+	Object.defineProperty(exports, "EtherSymbol", {
+		enumerable: true,
+		get: function() {
+			return strings_1.EtherSymbol;
+		}
+	});
+}));
+//#endregion
+export { require_lib$4 as a, require_lib$3 as i, require_lib$1 as n, require_lib$2 as r, require_lib as t };
+
+//# sourceMappingURL=lib-DH_xJGSE.mjs.map