bsv-mcp
Version:
A collection of Bitcoin SV (BSV) tools for the Model Context Protocol (MCP) framework
1,579 lines (1,577 loc) • 2.07 MB
JavaScript
#!/usr/bin/env bun
// @bun
import { createRequire } from "node:module";
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __require = /* @__PURE__ */ createRequire(import.meta.url);
// node_modules/@bsv/sdk/dist/cjs/src/primitives/BigNumber.js
var require_BigNumber = __commonJS((exports) => {
Object.defineProperty(exports, "__esModule", { value: true });
class BigNumber3 {
static isBN(num) {
if (num instanceof BigNumber3) {
return true;
}
return num !== null && typeof num === "object" && num.constructor.wordSize === BigNumber3.wordSize && Array.isArray(num.words);
}
static max(left, right) {
if (left.cmp(right) > 0)
return left;
return right;
}
static min(left, right) {
if (left.cmp(right) < 0)
return left;
return right;
}
constructor(number2 = 0, base = 10, endian = "be") {
this.negative = 0;
this.words = [];
this.length = 0;
this.red = null;
if (number2 !== null) {
if (base === "le" || base === "be") {
endian = base;
base = 10;
}
if (typeof number2 === "number") {
this.initNumber(number2, base, endian);
return;
}
if (typeof number2 === "object") {
this.initArray(number2, endian);
return;
}
if (base === "hex") {
base = 16;
}
this.assert(base === (base | 0) && base >= 2 && base <= 36);
number2 = number2.toString().replace(/\s+/g, "");
let start = 0;
if (number2.startsWith("-")) {
start++;
this.negative = 1;
}
if (start < number2.length) {
if (base === 16) {
this.parseHex(number2, start, endian);
} else {
this.parseBase(number2, base, start);
if (endian === "le") {
this.initArray(this.toArray(), endian);
}
}
}
}
}
assert(val, msg = "Assertion failed") {
if (!val)
throw new Error(msg);
}
initNumber(number2, base, endian) {
if (number2 < 0) {
this.negative = 1;
number2 = -number2;
}
if (number2 < 67108864) {
this.words = [number2 & 67108863];
this.length = 1;
} else if (number2 < 4503599627370496) {
this.words = [number2 & 67108863, number2 / 67108864 & 67108863];
this.length = 2;
} else {
this.assert(number2 <= 9007199254740991, "The number is larger than 2 ^ 53 (unsafe)");
this.words = [number2 & 67108863, number2 / 67108864 & 67108863, 1];
this.length = 3;
}
if (endian !== "le")
return this;
this.initArray(this.toArray(), endian);
return this;
}
initArray(number2, endian) {
this.assert(typeof number2.length === "number", "The number must have a length");
if (number2.length <= 0) {
this.words = [0];
this.length = 1;
return this;
}
this.length = Math.ceil(number2.length / 3);
this.words = new Array(this.length);
let i2 = 0;
for (;i2 < this.length; i2++) {
this.words[i2] = 0;
}
let j, w;
let off = 0;
if (endian === "be") {
for (i2 = number2.length - 1, j = 0;i2 >= 0; i2 -= 3) {
w = number2[i2] | number2[i2 - 1] << 8 | number2[i2 - 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 (i2 = 0, j = 0;i2 < number2.length; i2 += 3) {
w = number2[i2] | number2[i2 + 1] << 8 | number2[i2 + 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();
}
parseHex4Bits(string2, index) {
const c = string2.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 {
throw new Error("Invalid character in " + string2);
}
}
parseHexByte(string2, lowerBound, index) {
let r4 = this.parseHex4Bits(string2, index);
if (index - 1 >= lowerBound) {
r4 |= this.parseHex4Bits(string2, index - 1) << 4;
}
return r4;
}
parseHex(number2, start, endian) {
this.length = Math.ceil((number2.length - start) / 6);
this.words = new Array(this.length).fill(0);
let off = 0;
let j = 0;
const processHexByte = (i2) => {
const w = this.parseHexByte(number2, start, i2) << off;
this.words[j] |= w & 67108863;
if (off >= 18) {
off -= 18;
j += 1;
this.words[j] |= w >>> 26;
} else {
off += 8;
}
};
if (endian === "be") {
for (let i2 = number2.length - 1;i2 >= start; i2 -= 2) {
processHexByte(i2);
}
} else {
const parseLength = number2.length - start;
for (let i2 = parseLength % 2 === 0 ? start + 1 : start;i2 < number2.length; i2 += 2) {
processHexByte(i2);
}
}
return this.strip();
}
parseBaseWord(str, start, end, mul) {
let r4 = 0;
let b = 0;
const len = Math.min(str.length, end);
for (let i2 = start;i2 < len; i2++) {
const c = str.charCodeAt(i2) - 48;
r4 *= mul;
if (c >= 49) {
b = c - 49 + 10;
} else if (c >= 17) {
b = c - 17 + 10;
} else {
b = c;
}
this.assert(c >= 0 && b < mul, "Invalid character");
r4 += b;
}
return r4;
}
parseBase(number2, base, start) {
this.words = [0];
this.length = 1;
let limbLen = 0;
let limbPow = 1;
for (;limbPow <= 67108863; limbPow *= base) {
limbLen++;
}
limbLen--;
limbPow = limbPow / base | 0;
const total = number2.length - start;
const mod = total % limbLen;
const end = Math.min(total, total - mod) + start;
let word = 0;
let i2 = start;
for (;i2 < end; i2 += limbLen) {
word = this.parseBaseWord(number2, i2, i2 + limbLen, base);
this.imuln(limbPow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
if (mod !== 0) {
let pow = 1;
word = this.parseBaseWord(number2, i2, number2.length, base);
for (i2 = 0;i2 < mod; i2++) {
pow *= base;
}
this.imuln(pow);
if (this.words[0] + word < 67108864) {
this.words[0] += word;
} else {
this._iaddn(word);
}
}
return this.strip();
}
copy(dest) {
dest.words = new Array(this.length);
for (let i2 = 0;i2 < this.length; i2++) {
dest.words[i2] = this.words[i2];
}
dest.length = this.length;
dest.negative = this.negative;
dest.red = this.red;
}
static move(dest, src) {
dest.words = src.words;
dest.length = src.length;
dest.negative = src.negative;
dest.red = src.red;
}
clone() {
const r4 = new BigNumber3;
this.copy(r4);
return r4;
}
expand(size) {
while (this.length < size) {
this.words[this.length++] = 0;
}
return this;
}
strip() {
while (this.length > 1 && this.words[this.length - 1] === 0) {
this.length--;
}
return this.normSign();
}
normSign() {
if (this.length === 1 && this.words[0] === 0) {
this.negative = 0;
}
return this;
}
inspect() {
return (this.red !== null ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
}
toString(base = 10, padding = 1) {
if (base === 16 || base === "hex") {
return this.toHexString(padding);
}
if (base === (base | 0) && base >= 2 && base <= 36) {
return this.toBaseString(base, padding);
}
throw new Error("Base should be between 2 and 36");
}
toHexString(padding) {
let out = "";
let off = 0;
let carry = 0;
for (let i2 = 0;i2 < this.length; i2++) {
const w = this.words[i2];
const word = ((w << off | carry) & 16777215).toString(16);
carry = w >>> 24 - off & 16777215;
off += 2;
if (off >= 26) {
off -= 26;
i2--;
}
if (carry !== 0 || i2 !== this.length - 1) {
out = BigNumber3.zeros[6 - word.length] + word + out;
} else {
out = word + out;
}
}
if (carry !== 0) {
out = carry.toString(16) + out;
}
if (padding === 0 && out === "0") {
return "";
}
while (out.length % padding !== 0 && padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
toBaseString(base, padding) {
const groupSize = BigNumber3.groupSizes[base];
const groupBase = BigNumber3.groupBases[base];
let out = "";
let c = this.clone();
c.negative = 0;
while (!c.isZero()) {
const r4 = c.modrn(groupBase).toString(base);
c = c.idivn(groupBase);
if (!c.isZero()) {
out = BigNumber3.zeros[groupSize - r4.length] + r4 + out;
} else {
out = r4 + out;
}
}
if (this.isZero()) {
out = "0" + out;
}
while (out.length % padding !== 0) {
out = "0" + out;
}
if (this.negative !== 0) {
out = "-" + out;
}
return out;
}
toNumber() {
let 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) {
throw new Error("Number can only safely store up to 53 bits");
}
return this.negative !== 0 ? -ret : ret;
}
toJSON() {
return this.toString(16);
}
toArrayLikeLE(res, byteLength) {
let position = 0;
let carry = 0;
for (let i2 = 0, shift = 0;i2 < this.length; i2++) {
const word = this.words[i2] << 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;
}
}
}
toArrayLikeBE(res, byteLength) {
let position = res.length - 1;
let carry = 0;
for (let i2 = 0, shift = 0;i2 < this.length; i2++) {
const word = this.words[i2] << 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;
}
}
}
toArray(endian = "be", length) {
this.strip();
const byteLength = this.byteLength();
const reqLength = length !== null && length !== undefined ? length : Math.max(1, byteLength);
this.assert(byteLength <= reqLength, "byte array longer than desired length");
this.assert(reqLength > 0, "Requested array length <= 0");
const res = new Array(reqLength);
if (endian === "le") {
this.toArrayLikeLE(res, byteLength);
} else {
this.toArrayLikeBE(res, byteLength);
}
return res;
}
countWordBits(w) {
if (typeof Math.clz32 === "function") {
return 32 - Math.clz32(w);
}
let t2 = w;
let r4 = 0;
if (t2 >= 4096) {
r4 += 13;
t2 >>>= 13;
}
if (t2 >= 64) {
r4 += 7;
t2 >>>= 7;
}
if (t2 >= 8) {
r4 += 4;
t2 >>>= 4;
}
if (t2 >= 2) {
r4 += 2;
t2 >>>= 2;
}
return r4 + t2;
}
zeroWordBits(w) {
if (w === 0)
return 26;
let t2 = w;
let r4 = 0;
if ((t2 & 8191) === 0) {
r4 += 13;
t2 >>>= 13;
}
if ((t2 & 127) === 0) {
r4 += 7;
t2 >>>= 7;
}
if ((t2 & 15) === 0) {
r4 += 4;
t2 >>>= 4;
}
if ((t2 & 3) === 0) {
r4 += 2;
t2 >>>= 2;
}
if ((t2 & 1) === 0) {
r4++;
}
return r4;
}
bitLength() {
const w = this.words[this.length - 1];
const hi = this.countWordBits(w);
return (this.length - 1) * 26 + hi;
}
static toBitArray(num) {
const w = new Array(num.bitLength());
for (let bit = 0;bit < w.length; bit++) {
const off = bit / 26 | 0;
const wbit = bit % 26;
w[bit] = num.words[off] >>> wbit & 1;
}
return w;
}
toBitArray() {
return BigNumber3.toBitArray(this);
}
zeroBits() {
if (this.isZero())
return 0;
let r4 = 0;
for (let i2 = 0;i2 < this.length; i2++) {
const b = this.zeroWordBits(this.words[i2]);
r4 += b;
if (b !== 26)
break;
}
return r4;
}
byteLength() {
return Math.ceil(this.bitLength() / 8);
}
toTwos(width) {
if (this.negative !== 0) {
return this.abs().inotn(width).iaddn(1);
}
return this.clone();
}
fromTwos(width) {
if (this.testn(width - 1)) {
return this.notn(width).iaddn(1).ineg();
}
return this.clone();
}
isNeg() {
return this.negative !== 0;
}
neg() {
return this.clone().ineg();
}
ineg() {
if (!this.isZero()) {
this.negative ^= 1;
}
return this;
}
iuor(num) {
while (this.length < num.length) {
this.words[this.length++] = 0;
}
for (let i2 = 0;i2 < num.length; i2++) {
this.words[i2] = this.words[i2] | num.words[i2];
}
return this.strip();
}
ior(num) {
this.assert((this.negative | num.negative) === 0);
return this.iuor(num);
}
or(num) {
if (this.length > num.length)
return this.clone().ior(num);
return num.clone().ior(this);
}
uor(num) {
if (this.length > num.length)
return this.clone().iuor(num);
return num.clone().iuor(this);
}
iuand(num) {
const minLength = Math.min(this.length, num.length);
for (let i2 = 0;i2 < minLength; i2++) {
this.words[i2] = this.words[i2] & num.words[i2];
}
this.length = minLength;
return this.strip();
}
iand(num) {
this.assert((this.negative | num.negative) === 0);
return this.iuand(num);
}
and(num) {
if (this.length > num.length)
return this.clone().iand(num);
return num.clone().iand(this);
}
uand(num) {
if (this.length > num.length)
return this.clone().iuand(num);
return num.clone().iuand(this);
}
iuxor(num) {
if (this.length > num.length) {
for (let i2 = 0;i2 < num.length; i2++) {
this.words[i2] = this.words[i2] ^ num.words[i2];
}
} else {
for (let i2 = 0;i2 < this.length; i2++) {
this.words[i2] = this.words[i2] ^ num.words[i2];
}
for (let i2 = this.length;i2 < num.length; i2++) {
this.words[i2] = num.words[i2];
}
this.length = num.length;
}
return this.strip();
}
ixor(num) {
this.assert((this.negative | num.negative) === 0, "Neither number can be negative");
return this.iuxor(num);
}
xor(num) {
if (this.length > num.length)
return this.clone().ixor(num);
return num.clone().ixor(this);
}
uxor(num) {
if (this.length > num.length)
return this.clone().iuxor(num);
return num.clone().iuxor(this);
}
inotn(width) {
this.assert(typeof width === "number" && width >= 0, "The width needs to be a number greater than zero");
let bytesNeeded = Math.ceil(width / 26) | 0;
const bitsLeft = width % 26;
this.expand(bytesNeeded);
if (bitsLeft > 0) {
bytesNeeded--;
}
let i2 = 0;
for (;i2 < bytesNeeded; i2++) {
this.words[i2] = ~this.words[i2] & 67108863;
}
if (bitsLeft > 0) {
this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft;
}
return this.strip();
}
notn(width) {
return this.clone().inotn(width);
}
setn(bit, val) {
this.assert(typeof bit === "number" && bit >= 0);
const off = bit / 26 | 0;
const wbit = bit % 26;
this.expand(off + 1);
if (val === 1 || val === true) {
this.words[off] = this.words[off] | 1 << wbit;
} else {
this.words[off] = this.words[off] & ~(1 << wbit);
}
return this.strip();
}
iadd(num) {
let r4;
if (this.negative !== 0 && num.negative === 0) {
this.negative = 0;
r4 = this.isub(num);
this.negative ^= 1;
return this.normSign();
} else if (this.negative === 0 && num.negative !== 0) {
num.negative = 0;
r4 = this.isub(num);
num.negative = 1;
return r4.normSign();
}
let a2, b;
if (this.length > num.length) {
a2 = this;
b = num;
} else {
a2 = num;
b = this;
}
let carry = 0;
let i2 = 0;
for (;i2 < b.length; i2++) {
r4 = (a2.words[i2] | 0) + (b.words[i2] | 0) + carry;
this.words[i2] = r4 & 67108863;
carry = r4 >>> 26;
}
for (;carry !== 0 && i2 < a2.length; i2++) {
r4 = (a2.words[i2] | 0) + carry;
this.words[i2] = r4 & 67108863;
carry = r4 >>> 26;
}
this.length = a2.length;
if (carry !== 0) {
this.words[this.length] = carry;
this.length++;
} else if (a2 !== this) {
for (;i2 < a2.length; i2++) {
this.words[i2] = a2.words[i2];
}
}
return this;
}
add(num) {
let 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);
}
isub(num) {
let r4;
if (num.negative !== 0) {
num.negative = 0;
r4 = this.iadd(num);
num.negative = 1;
return r4.normSign();
} else if (this.negative !== 0) {
this.negative = 0;
this.iadd(num);
this.negative = 1;
return this.normSign();
}
const cmp = this.cmp(num);
if (cmp === 0) {
this.negative = 0;
this.length = 1;
this.words[0] = 0;
return this;
}
let a2, b;
if (cmp > 0) {
a2 = this;
b = num;
} else {
a2 = num;
b = this;
}
let carry = 0;
let i2 = 0;
for (;i2 < b.length; i2++) {
r4 = (a2.words[i2] | 0) - (b.words[i2] | 0) + carry;
carry = r4 >> 26;
this.words[i2] = r4 & 67108863;
}
for (;carry !== 0 && i2 < a2.length; i2++) {
r4 = (a2.words[i2] | 0) + carry;
carry = r4 >> 26;
this.words[i2] = r4 & 67108863;
}
if (carry === 0 && i2 < a2.length && a2 !== this) {
for (;i2 < a2.length; i2++) {
this.words[i2] = a2.words[i2];
}
}
this.length = Math.max(this.length, i2);
if (a2 !== this) {
this.negative = 1;
}
return this.strip();
}
sub(num) {
return this.clone().isub(num);
}
smallMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
let len = self2.length + num.length | 0;
out.length = len;
len = len - 1 | 0;
let a2 = self2.words[0] | 0;
let b = num.words[0] | 0;
let r4 = a2 * b;
const lo = r4 & 67108863;
let carry = r4 / 67108864 | 0;
out.words[0] = lo;
let k = 1;
for (;k < len; k++) {
let ncarry = carry >>> 26;
let rword = carry & 67108863;
const maxJ = Math.min(k, num.length - 1);
for (let j = Math.max(0, k - self2.length + 1);j <= maxJ; j++) {
const i2 = k - j | 0;
a2 = self2.words[i2] | 0;
b = num.words[j] | 0;
r4 = a2 * b + rword;
ncarry += r4 / 67108864 | 0;
rword = r4 & 67108863;
}
out.words[k] = rword | 0;
carry = ncarry | 0;
}
if (carry !== 0) {
out.words[k] = carry | 0;
} else {
out.length--;
}
return out.strip();
}
comb10MulTo(self2, num, out) {
const a2 = self2.words;
const b = num.words;
const o2 = out.words;
let c = 0;
let lo;
let mid;
let hi;
const a0 = a2[0] | 0;
const al0 = a0 & 8191;
const ah0 = a0 >>> 13;
const a1 = a2[1] | 0;
const al1 = a1 & 8191;
const ah1 = a1 >>> 13;
const a22 = a2[2] | 0;
const al2 = a22 & 8191;
const ah2 = a22 >>> 13;
const a3 = a2[3] | 0;
const al3 = a3 & 8191;
const ah3 = a3 >>> 13;
const a4 = a2[4] | 0;
const al4 = a4 & 8191;
const ah4 = a4 >>> 13;
const a5 = a2[5] | 0;
const al5 = a5 & 8191;
const ah5 = a5 >>> 13;
const a6 = a2[6] | 0;
const al6 = a6 & 8191;
const ah6 = a6 >>> 13;
const a7 = a2[7] | 0;
const al7 = a7 & 8191;
const ah7 = a7 >>> 13;
const a8 = a2[8] | 0;
const al8 = a8 & 8191;
const ah8 = a8 >>> 13;
const a9 = a2[9] | 0;
const al9 = a9 & 8191;
const ah9 = a9 >>> 13;
const b0 = b[0] | 0;
const bl0 = b0 & 8191;
const bh0 = b0 >>> 13;
const b1 = b[1] | 0;
const bl1 = b1 & 8191;
const bh1 = b1 >>> 13;
const b2 = b[2] | 0;
const bl2 = b2 & 8191;
const bh2 = b2 >>> 13;
const b3 = b[3] | 0;
const bl3 = b3 & 8191;
const bh3 = b3 >>> 13;
const b4 = b[4] | 0;
const bl4 = b4 & 8191;
const bh4 = b4 >>> 13;
const b5 = b[5] | 0;
const bl5 = b5 & 8191;
const bh5 = b5 >>> 13;
const b6 = b[6] | 0;
const bl6 = b6 & 8191;
const bh6 = b6 >>> 13;
const b7 = b[7] | 0;
const bl7 = b7 & 8191;
const bh7 = b7 >>> 13;
const b8 = b[8] | 0;
const bl8 = b8 & 8191;
const bh8 = b8 >>> 13;
const b9 = b[9] | 0;
const bl9 = b9 & 8191;
const bh9 = b9 >>> 13;
out.negative = self2.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);
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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;
let 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);
let w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
w18 &= 67108863;
o2[0] = w0;
o2[1] = w1;
o2[2] = w2;
o2[3] = w3;
o2[4] = w4;
o2[5] = w5;
o2[6] = w6;
o2[7] = w7;
o2[8] = w8;
o2[9] = w9;
o2[10] = w10;
o2[11] = w11;
o2[12] = w12;
o2[13] = w13;
o2[14] = w14;
o2[15] = w15;
o2[16] = w16;
o2[17] = w17;
o2[18] = w18;
if (c !== 0) {
o2[19] = c;
out.length++;
}
return out;
}
bigMulTo(self2, num, out) {
out.negative = num.negative ^ self2.negative;
out.length = self2.length + num.length;
let carry = 0;
let hncarry = 0;
let k = 0;
for (;k < out.length - 1; k++) {
let ncarry = hncarry;
hncarry = 0;
let rword = carry & 67108863;
const maxJ = Math.min(k, num.length - 1);
for (let j = Math.max(0, k - self2.length + 1);j <= maxJ; j++) {
const i2 = k - j;
const a2 = self2.words[i2] | 0;
const b = num.words[j] | 0;
const r4 = a2 * b;
let lo = r4 & 67108863;
ncarry = ncarry + (r4 / 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();
}
mulTo(num, out) {
let res;
const len = this.length + num.length;
if (this.length === 10 && num.length === 10) {
res = this.comb10MulTo(this, num, out);
} else if (len < 63) {
res = this.smallMulTo(this, num, out);
} else {
res = this.bigMulTo(this, num, out);
}
return res;
}
mul(num) {
const out = new BigNumber3;
out.words = new Array(this.length + num.length);
return this.mulTo(num, out);
}
imul(num) {
return this.clone().mulTo(num, this);
}
imuln(num) {
const isNegNum = num < 0;
if (isNegNum)
num = -num;
this.assert(typeof num === "number");
this.assert(num < 67108864);
let carry = 0;
let i2 = 0;
for (;i2 < this.length; i2++) {
const w = (this.words[i2] | 0) * num;
const lo = (w & 67108863) + (carry & 67108863);
carry >>= 26;
carry += w / 67108864 | 0;
carry += lo >>> 26;
this.words[i2] = lo & 67108863;
}
if (carry !== 0) {
this.words[i2] = carry;
this.length++;
}
return isNegNum ? this.ineg() : this;
}
muln(num) {
return this.clone().imuln(num);
}
sqr() {
return this.mul(this);
}
isqr() {
return this.imul(this.clone());
}
pow(num) {
const w = BigNumber3.toBitArray(num);
if (w.length === 0)
return new BigNumber3(1);
let res = this;
let i2 = 0;
for (;i2 < w.length; i2++, res = res.sqr()) {
if (w[i2] !== 0)
break;
}
if (++i2 < w.length) {
for (let q = res.sqr();i2 < w.length; i2++, q = q.sqr()) {
if (w[i2] === 0)
continue;
res = res.mul(q);
}
}
return res;
}
iushln(bits) {
this.assert(typeof bits === "number" && bits >= 0);
const r4 = bits % 26;
const s3 = (bits - r4) / 26;
const carryMask = 67108863 >>> 26 - r4 << 26 - r4;
let i2;
if (r4 !== 0) {
let carry = 0;
for (i2 = 0;i2 < this.length; i2++) {
const newCarry = this.words[i2] & carryMask;
const c = (this.words[i2] | 0) - newCarry << r4;
this.words[i2] = c | carry;
carry = newCarry >>> 26 - r4;
}
if (carry !== 0) {
this.words[i2] = carry;
this.length++;
}
}
if (s3 !== 0) {
for (i2 = this.length - 1;i2 >= 0; i2--) {
this.words[i2 + s3] = this.words[i2];
}
for (i2 = 0;i2 < s3; i2++) {
this.words[i2] = 0;
}
this.length += s3;
}
return this.strip();
}
ishln(bits) {
this.assert(this.negative === 0);
return this.iushln(bits);
}
iushrn(bits, hint, extended) {
this.assert(typeof bits === "number" && bits >= 0);
let h;
if (typeof hint === "number" && hint !== 0) {
h = (hint - hint % 26) / 26;
} else {
h = 0;
}
const r4 = bits % 26;
const s3 = Math.min((bits - r4) / 26, this.length);
const mask = 67108863 ^ 67108863 >>> r4 << r4;
const maskedWords = extended;
h -= s3;
h = Math.max(0, h);
let i2 = 0;
if (typeof maskedWords !== "undefined") {
for (;i2 < s3; i2++) {
maskedWords.words[i2] = this.words[i2];
}
maskedWords.length = s3;
}
if (s3 === 0) {} else if (this.length > s3) {
this.length -= s3;
for (i2 = 0;i2 < this.length; i2++) {
this.words[i2] = this.words[i2 + s3];
}
} else {
this.words[0] = 0;
this.length = 1;
}
let carry = 0;
for (i2 = this.length - 1;i2 >= 0 && (carry !== 0 || i2 >= h); i2--) {
const word = this.words[i2] | 0;
this.words[i2] = carry << 26 - r4 | word >>> r4;
carry = word & mask;
}
if (maskedWords != null && carry !== 0) {
maskedWords.words[maskedWords.length++] = carry;
}
if (this.length === 0) {
this.words[0] = 0;
this.length = 1;
}
return this.strip();
}
ishrn(bits, hint, extended) {
this.assert(this.negative === 0);
return this.iushrn(bits, hint, extended);
}
shln(bits) {
return this.clone().ishln(bits);
}
ushln(bits) {
return this.clone().iushln(bits);
}
shrn(bits) {
return this.clone().ishrn(bits);
}
ushrn(bits) {
return this.clone().iushrn(bits);
}
testn(bit) {
this.assert(typeof bit === "number" && bit >= 0);
const r4 = bit % 26;
const s3 = (bit - r4) / 26;
const q = 1 << r4;
if (this.length