// Metro module 14 (f15).
function $mk100897($env) {
  return function(a0) {
    const r2 = $env[0] || $env.$parent[1];
    return a0 < r2.length ? r2[a0] : "<" + a0 + ">";
  };
}
let BigInteger, SmallInteger, NativeBigInt, arrayToSmall, addAny, subtract, subtractSmall, multiplyLong, multiplyKaratsuba, multiplySmallAndArray, square, divModAny, millerRabinTest, bitwise, integerLogarithm, gcd, toBase, parseStringValue, parseValue, c35_0, c35_1, c35_2, c35_17, length, c35_19, c35_21, parseBase;
let env34;
const r8 = env34 = {};
let env35 = {
  $parent: r8
};
const Integer = function Integer(a0, a1, a2, a3) {
  "use strict";
  let r1, r26, r64;
  L39: {
    if (a0 === void 0) {
      r26 = Integer[0];
    } else {
      L4: {
        if (a1 !== void 0) {
          let r15 = a2;
          if (+a1 === 10 && !a2) {
            break L4;
          }
          if (!a2) {
            r15 = c35_1;
          }
          const r29 = String(a0);
          let r30 = r15;
          let r17 = r29;
          if (!a3) {
            r17 = r29.toLowerCase();
            r30 = r15.toLowerCase();
          }
          const length2 = r17.length;
          const r36 = Math.abs(a1);
          const r16 = {};
          const r7 = 0 < r30.length;
          let r39 = 0;
          if (r7) {
            do {
              r16[r30[r39]] = r39;
              r39 = r39 + 1;
            } while (r39 < r30.length);
          }
          const r42 = 0 < length2;
          let r45 = 0;
          if (r42) {
            do {
              L20: {
                const r20 = r17[r45];
                r1 = r45;
                if (r20 !== "-" && r20 in r16 && r16[r20] >= r36) {
                  if (r20 === "1" && r36 === 1) {
                    break L20;
                  }
                  throw new Error(r20 + " is not a valid digit in base " + a1 + ".");
                }
              }
              r45 = r1 + 1;
            } while (r45 < length2);
          }
          const r55 = parseValue(a1);
          const r57 = r17[0] === "-";
          let r58 = r57 ? 1 : 0;
          const r59 = [];
          while (r58 < r17.length) {
            const r63 = r17[r58];
            const r8 = r63 in r16;
            const r4 = r58;
            if (r8) {
              r59.push(parseValue(r16[r63]));
              r64 = r4;
            } else {
              let r0 = r4;
              if (r63 !== "<") {
                throw new Error(r63 + " is not a valid character");
              }
              while (true) {
                r64 = r0 + 1;
                if (r17[r64] !== ">") {
                  const length3 = r17.length;
                  r0 = r64;
                  if (r64 < length3) {
                    continue;
                  }
                }
                r59.push(parseValue(r17.slice(r4 + 1, r64)));
                break;
              }
            }
            r58 = r64 + 1;
          }
          const r88 = Integer[0];
          let r89 = Integer[1];
          let r91 = r59.length - 1;
          let r92 = r88;
          let r93 = r92;
          while (0 <= r91) {
            r92 = r92.add(r59[r91].times(r89));
            r89 = r89.times(r55);
            r91 = r91 - 1;
            r93 = r92;
          }
          r26 = r57 ? r93.negate() : r93;
          break L39;
        }
      }
      r26 = parseValue(a0);
    }
  }
  return r26;
};
BigInteger = function BigInteger(a0, a1) {
  "use strict";
  this.value = a0;
  this.sign = a1;
  this.isSmall = false;
};
SmallInteger = function SmallInteger(a0) {
  "use strict";
  this.value = a0;
  this.sign = a0 < 0;
  this.isSmall = true;
};
NativeBigInt = function NativeBigInt(a0) {
  "use strict";
  this.value = a0;
};
arrayToSmall = function arrayToSmall(a0) {
  "use strict";
  let r14, r22;
  const r12 = a0.length - 1;
  const r9 = a0[r12];
  let r10 = r12;
  let r13 = r10;
  if (r9 === 0) {
    do {
      const r11 = r10 - 1;
      r14 = a0[r11];
      r10 = r11;
      r13 = r10;
    } while (r14 === 0);
  }
  a0.length = r13 + 1;
  const length2 = a0.length;
  if (length2 < 4) {
    if (a0.length !== c35_0.length) {
      r22 = a0.length > c35_0.length ? 1 : -1;
    } else {
      let r0 = a0.length - 1;
      r22 = 0;
      while (0 <= r0) {
        const r23 = a0[r0];
        const r24 = c35_0[r0];
        const r1 = r0;
        if (r23 !== r24) {
          r22 = a0[r1] > c35_0[r1] ? 1 : -1;
          break;
        }
        r0 = r1 - 1;
        r22 = 0;
      }
    }
    if (r22 < 0) {
      if (length2 === 0) {
        return 0;
      }
      if (length2 === 1) {
        return a0[0];
      }
      if (length2 === 2) {
        return a0[0] + a0[1] * 10000000;
      }
      return a0[0] + (a0[1] + a0[2] * 10000000) * 10000000;
    }
  }
  return a0;
};
addAny = function addAny(a0, a1) {
  "use strict";
  let r38;
  if (a0.length >= a1.length) {
    const length4 = a0.length;
    const length5 = a1.length;
    const array2 = new Array(length4);
    const r51 = 0 < length5;
    let r54 = 0;
    let r55 = 0;
    let r56 = 0;
    let r57 = 0;
    if (r51) {
      do {
        const r60 = a0[r55] + a1[r55] + r54;
        const r61 = r55;
        const r62 = r60 >= 10000000 ? 1 : 0;
        array2[r61] = r60 - r62 * 10000000;
        r55 = r61 + 1;
        r54 = r62;
        r56 = r54;
        r57 = r55;
      } while (r57 < length5);
    }
    let r65 = r56;
    let r66 = r65;
    while (r57 < length4) {
      const r68 = a0[r57] + r65;
      const r69 = r57;
      const r70 = r68 === 10000000 ? 1 : 0;
      r57 = r69 + 1;
      array2[r69] = r68 - r70 * 10000000;
      r65 = r70;
      r66 = r65;
    }
    r38 = array2;
    if (0 < r66) {
      array2.push(r66);
      r38 = array2;
    }
  } else {
    const length3 = a1.length;
    const length2 = a0.length;
    const array = new Array(length3);
    const r10 = 0 < length2;
    let r4 = 0;
    let r0 = 0;
    let r7 = 0;
    let r3 = 0;
    if (r10) {
      do {
        const r28 = a1[r0] + a0[r0] + r4;
        const r2 = r0;
        const r1 = r28 >= 10000000 ? 1 : 0;
        array[r2] = r28 - r1 * 10000000;
        r0 = r2 + 1;
        r4 = r1;
        r7 = r4;
        r3 = r0;
      } while (r3 < length2);
    }
    let r30 = r7;
    let r31 = r30;
    while (r3 < length3) {
      const r33 = a1[r3] + r30;
      const r34 = r3;
      const r35 = r33 === 10000000 ? 1 : 0;
      r3 = r34 + 1;
      array[r34] = r33 - r35 * 10000000;
      r30 = r35;
      r31 = r30;
    }
    r38 = array;
    if (0 < r31) {
      array.push(r31);
      r38 = array;
    }
  }
  return r38;
};
subtract = function subtract(a0, a1) {
  "use strict";
  let r40;
  const length3 = a0.length;
  const length2 = a1.length;
  const array = new Array(length3);
  const r10 = 0 < length2;
  let r1 = 0;
  let r0 = 0;
  let r6 = 0;
  if (r10) {
    do {
      const r5 = a0[r0] - r1 - a1[r0];
      const r26 = r0;
      let r2 = 0;
      let r3 = r5;
      if (r3 < 0) {
        r3 = r5 + 10000000;
        r2 = 1;
      }
      array[r26] = r3;
      r0 = r26 + 1;
      r1 = r2;
      r6 = r1;
    } while (r0 < length2);
  }
  let r27 = length2;
  let r28 = r27;
  while (r28 < length3) {
    const r30 = a0[r27] - r6;
    const r31 = r27;
    if (!(r30 < 0)) {
      const r18 = +r31;
      r28 = r18 + 1;
      array[r18] = r30;
      break;
    }
    array[r31] = r30 + 10000000;
    r27 = r31 + 1;
    r28 = r27;
  }
  while (r28 < length3) {
    array[r28] = a0[r28];
    r28 = r28 + 1;
  }
  const r35 = array.length - 1;
  const r36 = array[r35];
  let r37 = r35;
  let r38 = r37;
  if (r36 === 0) {
    do {
      const r39 = r37 - 1;
      r40 = array[r39];
      r37 = r39;
      r38 = r37;
    } while (r40 === 0);
  }
  array.length = r38 + 1;
  return array;
};
subtractSmall = function subtractSmall(a0, a1, a2) {
  "use strict";
  let r31;
  const length2 = a0.length;
  const array = new Array(length2);
  let r21 = -a1;
  const r7 = 0 < length2;
  let r0 = 0;
  if (r7) {
    do {
      const r14 = a0[r0] + r21;
      const r23 = Math.floor(r14 / 10000000);
      const r4 = r14 % 10000000;
      const r24 = r0;
      let r1 = r4;
      if (r1 < 0) {
        r1 = r4 + 10000000;
      }
      array[r24] = r1;
      r0 = r24 + 1;
      r21 = r23;
    } while (r0 < length2);
  }
  const value = arrayToSmall(array);
  if (typeof value === "number") {
    const value2 = a2 ? -value : value;
    const r36 = {
      __proto__: SmallInteger.prototype
    };
    r36.value = value2;
    r36.sign = value2 < 0;
    r36.isSmall = true;
    r31 = r36;
  } else {
    r31 = {
      __proto__: BigInteger.prototype
    };
    r31.value = value;
    r31.sign = a2;
    r31.isSmall = false;
  }
  return r31;
};
multiplyLong = function multiplyLong(a0, a1) {
  "use strict";
  let r42;
  const length3 = a0.length;
  const length2 = a1.length;
  const r15 = length3 + length2;
  const array = new Array(r15);
  let r6 = 0;
  while (r6 < r15) {
    array[r6] = 0;
    r6 = r6 + 1;
  }
  const r8 = 0 < length3;
  let r23 = 0;
  if (r8) {
    do {
      const r24 = a0[r23];
      const r25 = 0 < length2;
      const r5 = r23;
      let r0 = 0;
      if (r25) {
        do {
          const r17 = r24 * a1[r0];
          const r2 = r5 + r0;
          const r28 = r17 + array[r2];
          const r30 = Math.floor(r28 / 10000000);
          array[r2] = r28 - r30 * 10000000;
          const r33 = r2 + 1;
          array[r33] = array[r33] + r30;
          r0 = r0 + 1;
        } while (r0 < length2);
      }
      r23 = r5 + 1;
    } while (r23 < length3);
  }
  const r37 = array.length - 1;
  const r38 = array[r37];
  let r39 = r37;
  let r40 = r39;
  if (r38 === 0) {
    do {
      const r41 = r39 - 1;
      r42 = array[r41];
      r39 = r41;
      r40 = r39;
    } while (r42 === 0);
  }
  array.length = r40 + 1;
  return array;
};
multiplyKaratsuba = function multiplyKaratsuba(a0, a1) {
  "use strict";
  let r42, r50, r60;
  const r17 = Math.max(a0.length, a1.length);
  if (r17 <= 30) {
    return multiplyLong(a0, a1);
  }
  const r21 = Math.ceil(r17 / 2);
  const r16 = a0.slice(r21);
  const r13 = a0.slice(0, r21);
  const r15 = a1.slice(r21);
  const r27 = a1.slice(0, r21);
  const r28 = multiplyKaratsuba(r13, r27);
  const r29 = multiplyKaratsuba(r16, r15);
  const r33 = multiplyKaratsuba(addAny(r13, r16), addAny(r27, r15));
  const r36 = subtract(subtract(r33, r28), r29);
  const r37 = [];
  const r38 = +r21;
  let r39 = r38 - 1;
  if (r38 > 0) {
    do {
      r37.push(0);
      r42 = +r39;
      r39 = r42 - 1;
    } while (r42 > 0);
  }
  const r45 = addAny(r28, r37.concat(r36));
  const r4 = 2 * r21;
  const r46 = [];
  let r0 = r4 - 1;
  if (0 < r4) {
    do {
      r46.push(0);
      const r2 = r0 - 1;
      r50 = r0;
      r0 = r2;
    } while (0 < r50);
  }
  const r53 = addAny(r45, r46.concat(r29));
  const r55 = r53.length - 1;
  const r56 = r53[r55];
  let r57 = r55;
  let r58 = r57;
  if (r56 === 0) {
    do {
      const r59 = r57 - 1;
      r60 = r53[r59];
      r57 = r59;
      r58 = r57;
    } while (r60 === 0);
  }
  r53.length = r58 + 1;
  return r53;
};
multiplySmallAndArray = function multiplySmallAndArray(a0, a1, a2) {
  "use strict";
  let value;
  if (a0 < 10000000) {
    const length2 = a1.length;
    const array = new Array(length2);
    const r6 = 0 < length2;
    let r46 = 0;
    let r0 = 0;
    let r47 = 0;
    let r48 = 0;
    if (r6) {
      do {
        const r17 = a1[r0] * a0 + r46;
        const r51 = Math.floor(r17 / 10000000);
        array[r0] = r17 - r51 * 10000000;
        r0 = r0 + 1;
        r46 = r51;
        r47 = r46;
        r48 = r0;
      } while (r48 < length2);
    }
    value = array;
    while (r47 > 0) {
      const r54 = r48 + 1;
      array[r48] = r47 % 10000000;
      r47 = Math.floor(r47 / 10000000);
      r48 = r54;
      value = array;
    }
  } else {
    value = multiplyLong(a1, a0 < 10000000 ? [a0] : a0 < 100000000000000 ? [a0 % 10000000, Math.floor(a0 / 10000000)] : [a0 % 10000000, Math.floor(a0 / 10000000) % 10000000, Math.floor(a0 / 100000000000000)]);
  }
  const r61 = {
    __proto__: BigInteger.prototype
  };
  r61.value = value;
  r61.sign = a2;
  r61.isSmall = false;
  return r61;
};
square = function square(a0) {
  "use strict";
  let r43;
  const length2 = a0.length;
  const r14 = length2 + length2;
  const array = new Array(r14);
  let r6 = 0;
  while (r6 < r14) {
    array[r6] = 0;
    r6 = r6 + 1;
  }
  const r9 = 0 < length2;
  let r24 = 0;
  if (r9) {
    do {
      const r16 = a0[r24];
      let r26 = 0 - r16 * r16;
      const r4 = r24;
      let r27 = r26;
      let r0 = r4;
      while (r0 < length2) {
        const r1 = r16 * a0[r0] * 2;
        const r3 = r4 + r0;
        const r18 = r1 + array[r3] + r26;
        const r33 = Math.floor(r18 / 10000000);
        array[r3] = r18 - r33 * 10000000;
        r0 = r0 + 1;
        r26 = r33;
        r27 = r26;
      }
      array[r4 + length2] = r27;
      r24 = r4 + 1;
    } while (r24 < length2);
  }
  const r38 = array.length - 1;
  const r39 = array[r38];
  let r40 = r38;
  let r41 = r40;
  if (r39 === 0) {
    do {
      const r42 = r40 - 1;
      r43 = array[r42];
      r40 = r42;
      r41 = r40;
    } while (r43 === 0);
  }
  array.length = r41 + 1;
  return array;
};
divModAny = function divModAny(a0, a1) {
  "use strict";
  let r70, r99, r103, r157, r173, r181, r297, r314, r355, r364, r421, r449;
  const r47 = parseValue(a1);
  if (c35_2) {
    const value12 = a0.value / r47.value;
    const r480 = {
      __proto__: NativeBigInt.prototype
    };
    r480.value = value12;
    const value13 = a0.value % r47.value;
    const r485 = {
      __proto__: NativeBigInt.prototype
    };
    r485.value = value13;
    return [r480, r485];
  }
  const value2 = a0.value;
  const value = r47.value;
  if (value === 0) {
    throw new Error("Cannot divide by zero");
  }
  const isSmall = a0.isSmall;
  const isSmall2 = r47.isSmall;
  if (isSmall) {
    if (isSmall2) {
      const r451 = value2 / value;
      const value10 = r451 > 0 ? Math.floor(r451) : Math.ceil(r451);
      const r460 = {
        __proto__: SmallInteger.prototype
      };
      r460.value = value10;
      r460.sign = value10 < 0;
      r460.isSmall = true;
      const value11 = value2 % value;
      const r465 = {
        __proto__: SmallInteger.prototype
      };
      r465.value = value11;
      r465.sign = value11 < 0;
      r465.isSmall = true;
      r449 = [r460, r465];
    } else {
      r449 = [Integer[0], a0];
    }
    return r449;
  }
  let r37 = value;
  if (isSmall2) {
    if (value === 1) {
      return [a0, Integer[0]];
    }
    if (value == -1) {
      return [a0.negate(), Integer[0]];
    }
    const r51 = Math.abs(value);
    if (r51 < 10000000) {
      const length13 = value2.length;
      const array6 = new Array(length13);
      const r390 = 0 < length13;
      let r391 = 0;
      if (r390) {
        do {
          array6[r391] = 0;
          r391 = r391 + 1;
        } while (r391 < length13);
      }
      let r392 = length13 - 1;
      let r393 = 0;
      let r394 = 0;
      while (0 <= r392) {
        const r397 = r393 * 10000000 + value2[r392];
        const r398 = r397 / r51;
        const r399 = r392;
        const r402 = 0 < r398 ? Math.floor(r398) : Math.ceil(r398);
        r393 = r397 - r402 * r51;
        array6[r399] = r402 | 0;
        r392 = r399 - 1;
        r394 = r393;
      }
      const r408 = [array6, r394 | 0];
      const value7 = arrayToSmall(r408[0]);
      const r411 = r408[1];
      const value8 = a0.sign ? -r411 : r411;
      if (typeof value7 === "number") {
        const value9 = a0.sign !== r47.sign ? -value7 : value7;
        const r432 = {
          __proto__: SmallInteger.prototype
        };
        r432.value = value9;
        r432.sign = value9 < 0;
        r432.isSmall = true;
        const r437 = {
          __proto__: SmallInteger.prototype
        };
        r437.value = value8;
        r437.sign = value8 < 0;
        r437.isSmall = true;
        r421 = [r432, r437];
      } else {
        const sign2 = a0.sign;
        const sign3 = r47.sign;
        const r418 = {
          __proto__: BigInteger.prototype
        };
        r418.value = value7;
        r418.sign = sign2 !== sign3;
        r418.isSmall = false;
        const r424 = {
          __proto__: SmallInteger.prototype
        };
        r424.value = value8;
        r424.sign = value8 < 0;
        r424.isSmall = true;
        r421 = [r418, r424];
      }
      return r421;
    }
    r37 = r51 < 10000000 ? [r51] : r51 < 100000000000000 ? [r51 % 10000000, Math.floor(r51 / 10000000)] : [r51 % 10000000, Math.floor(r51 / 10000000) % 10000000, Math.floor(r51 / 100000000000000)];
  }
  if (value2.length !== r37.length) {
    r70 = value2.length > r37.length ? 1 : -1;
  } else {
    let r7 = value2.length - 1;
    r70 = 0;
    while (0 <= r7) {
      const r71 = value2[r7];
      const r72 = r37[r7];
      const r73 = r7;
      if (r71 !== r72) {
        r70 = value2[r73] > r37[r73] ? 1 : -1;
        break;
      }
      r7 = r73 - 1;
      r70 = 0;
    }
  }
  let r82 = -1;
  if (r70 === -1) {
    return [Integer[0], a0];
  }
  if (r70 === 0) {
    if (a0.sign === r47.sign) {
      r82 = 1;
    }
    return [Integer[r82], Integer[0]];
  }
  if (value2.length + r37.length <= 200) {
    const length6 = value2.length;
    const { length: length7, length: length8 } = r37;
    const array2 = new Array(length8);
    const r192 = 0 < length8;
    let r194 = 0;
    if (r192) {
      do {
        array2[r194] = 0;
        r194 = r194 + 1;
      } while (r194 < length8);
    }
    const r203 = Math.ceil(10000000 / (2 * r37[length7 - 1]));
    const length9 = value2.length;
    const array3 = new Array(length9);
    const r211 = 0 < length9;
    let r212 = 0;
    let r213 = 0;
    let r214 = 0;
    let r215 = 0;
    if (r211) {
      do {
        const r218 = value2[r213] * r203 + r212;
        const r222 = Math.floor(r218 / 10000000);
        array3[r213] = r218 - r222 * 10000000;
        r213 = r213 + 1;
        r212 = r222;
        r214 = r212;
        r215 = r213;
      } while (r215 < length9);
    }
    while (r214 > 0) {
      const r225 = r215 + 1;
      array3[r215] = r214 % 10000000;
      r214 = Math.floor(r214 / 10000000);
      r215 = r225;
    }
    const length10 = r37.length;
    const array4 = new Array(length10);
    const r237 = 0 < length10;
    let r238 = 0;
    let r239 = 0;
    let r240 = 0;
    let r241 = 0;
    if (r237) {
      do {
        const r244 = r37[r239] * r203 + r238;
        const r248 = Math.floor(r244 / 10000000);
        array4[r239] = r244 - r248 * 10000000;
        r239 = r239 + 1;
        r238 = r248;
        r240 = r238;
        r241 = r239;
      } while (r241 < length10);
    }
    while (r240 > 0) {
      const r251 = r241 + 1;
      array4[r241] = r240 % 10000000;
      r240 = Math.floor(r240 / 10000000);
      r241 = r251;
    }
    if (array3.length <= length6) {
      array3.push(0);
    }
    array4.push(0);
    const r262 = array4[length7 - 1];
    let r263 = length6 - length7;
    while (r263 >= 0) {
      const r266 = array3[r263 + length7];
      const r267 = r263;
      const r268 = r266 !== r262 ? Math.floor((array3[r267 + length7] * 10000000 + array3[r267 + length7 - 1]) / r262) : 9999999;
      const length11 = array4.length;
      const r280 = 0 < length11;
      let r281 = 0;
      let r282 = 0;
      let r283 = 0;
      let r284 = 0;
      if (r280) {
        do {
          const r287 = r283 + r268 * array4[r281];
          const r290 = Math.floor(r287 / 10000000);
          const r4 = r282 + (array3[r267 + r281] - (r287 - r290 * 10000000));
          const r296 = r281;
          if (r4 < 0) {
            array3[r267 + r296] = r4 + 10000000;
            r297 = -1;
          } else {
            array3[r267 + r296] = r4;
            r297 = 0;
          }
          r281 = r296 + 1;
          r282 = r297;
          r283 = r290;
          r284 = r282;
        } while (r281 < length11);
      }
      let r299 = r268;
      let r300 = r299;
      while (r284 !== 0) {
        const r301 = r299 - 1;
        const r302 = 0 < length11;
        const r303 = r284;
        let r304 = 0;
        let r305 = 0;
        let r306 = 0;
        if (r302) {
          do {
            const r312 = r305 + (array3[r267 + r304] - 10000000 + array4[r304]);
            const r313 = r304;
            if (r312 < 0) {
              array3[r267 + r313] = r312 + 10000000;
              r314 = 0;
            } else {
              array3[r267 + r313] = r312;
              r314 = 1;
            }
            r304 = r313 + 1;
            r305 = r314;
            r306 = r305;
          } while (r304 < length11);
        }
        r284 = r303 + r306;
        r299 = r301;
        r300 = r299;
      }
      array2[r267] = r300;
      r263 = r267 - 1;
    }
    const length12 = array3.length;
    const array5 = new Array(length12);
    const r323 = 0 < length12;
    let r324 = 0;
    if (r323) {
      do {
        array5[r324] = 0;
        r324 = r324 + 1;
      } while (r324 < length12);
    }
    let r325 = length12 - 1;
    let r326 = 0;
    let r327 = 0;
    while (0 <= r325) {
      const r330 = r326 * 10000000 + array3[r325];
      const r331 = r330 / r203;
      const r332 = r325;
      const r335 = 0 < r331 ? Math.floor(r331) : Math.ceil(r331);
      r326 = r330 - r335 * r203;
      array5[r332] = r335 | 0;
      r325 = r332 - 1;
      r327 = r326;
    }
    const r342 = [array5, r327 | 0][0];
    r181 = [arrayToSmall(array2), arrayToSmall(r342)];
  } else {
    let length3 = value2.length;
    const length2 = r37.length;
    const r87 = [];
    let r88 = [];
    let r93 = r88;
    while (length3) {
      const unshift = r88.unshift;
      const r32 = length3 - 1;
      unshift.call(r88, value2[r32]);
      const r96 = r88.length - 1;
      const r35 = r88[r96];
      const r97 = r88;
      let r36 = r96;
      let r98 = r36;
      if (r35 === 0) {
        do {
          const r38 = r36 - 1;
          r99 = r97[r38];
          r36 = r38;
          r98 = r36;
        } while (r99 === 0);
      }
      r97.length = r98 + 1;
      if (r97.length !== r37.length) {
        r103 = r97.length > r37.length ? 1 : -1;
      } else {
        let r0 = r97.length - 1;
        r103 = 0;
        while (0 <= r0) {
          const r104 = r97[r0];
          const r105 = r37[r0];
          const r1 = r0;
          if (r104 !== r105) {
            r103 = r97[r1] > r37[r1] ? 1 : -1;
            break;
          }
          r0 = r1 - 1;
          r103 = 0;
        }
      }
      if (r103 < 0) {
        r87.push(0);
        r173 = r97;
      } else {
        const length5 = r97.length;
        const r120 = r97[length5 - 1] * 10000000 + r97[length5 - 2];
        let r132 = Math.ceil((length5 > length2 ? (r120 + 1) * 10000000 : r120) / (r37[length2 - 1] * 10000000 + r37[length2 - 2]));
        while (true) {
          const length4 = r37.length;
          const array = new Array(length4);
          const r137 = 0 < length4;
          const r138 = r132;
          let r39 = 0;
          let r139 = 0;
          let r140 = 0;
          let r141 = 0;
          if (r137) {
            do {
              const r42 = r37[r139] * r138 + r39;
              const r145 = Math.floor(r42 / 10000000);
              array[r139] = r42 - r145 * 10000000;
              r139 = r139 + 1;
              r39 = r145;
              r140 = r39;
              r141 = r139;
            } while (r141 < length4);
          }
          while (r140 > 0) {
            const r148 = r141 + 1;
            array[r141] = r140 % 10000000;
            r140 = Math.floor(r140 / 10000000);
            r141 = r148;
          }
          if (array.length !== r97.length) {
            r157 = array.length > r97.length ? 1 : -1;
          } else {
            let r156 = array.length - 1;
            r157 = 0;
            while (0 <= r156) {
              const r158 = array[r156];
              const r159 = r97[r156];
              const r160 = r156;
              if (r158 !== r159) {
                r157 = array[r160] > r97[r160] ? 1 : -1;
                break;
              }
              r156 = r160 - 1;
              r157 = 0;
            }
          }
          let r169 = r138;
          if (!(r157 <= 0)) {
            r132 = r138 - 1;
            r169 = r132;
            if (r169) {
              continue;
            }
          }
          r87.push(r169);
          r173 = subtract(r97, array);
          break;
        }
      }
      r88 = r173;
      r93 = r88;
      length3 = r32;
    }
    r87.reverse();
    r181 = [arrayToSmall(r87), arrayToSmall(r93)];
  }
  const value3 = r181[0];
  const sign4 = a0.sign !== r47.sign;
  const value4 = r181[1];
  const sign = a0.sign;
  if (typeof value3 === "number") {
    const value5 = sign4 ? -value3 : value3;
    const r359 = {
      __proto__: SmallInteger.prototype
    };
    r359.value = value5;
    r359.sign = value5 < 0;
    r359.isSmall = true;
    r355 = r359;
  } else {
    r355 = {
      __proto__: BigInteger.prototype
    };
    r355.value = value3;
    r355.sign = sign4;
    r355.isSmall = false;
  }
  if (typeof value4 === "number") {
    const value6 = sign ? -value4 : value4;
    const r369 = {
      __proto__: SmallInteger.prototype
    };
    r369.value = value6;
    r369.sign = value6 < 0;
    r369.isSmall = true;
    r364 = r369;
  } else {
    r364 = {
      __proto__: BigInteger.prototype
    };
    r364.value = value4;
    r364.sign = sign;
    r364.isSmall = false;
  }
  return [r355, r364];
};
millerRabinTest = function millerRabinTest(a0, a1) {
  "use strict";
  let r29, isEven2;
  const r12 = a0.prev();
  const isEven = r12.isEven();
  let r4 = 0;
  let r10 = r12;
  let r3 = 0;
  let r11 = r10;
  if (isEven) {
    do {
      const r15 = r10.divide(2);
      r4 = r4 + 1;
      isEven2 = r15.isEven();
      r10 = r15;
      r3 = r4;
      r11 = r10;
    } while (isEven2);
  }
  const r8 = 0 < a1.length;
  const r24 = r3 - 1;
  let r25 = 0;
  if (r8) {
    do {
      L12: {
        const r28 = a0.lesser(a1[r25]);
        r29 = r25;
        if (!r28) {
          let r34 = (0, env34[0])(a1[r29]).modPow(r11, a0);
          if (!r34.isUnit() && !r34.equals(r12)) {
            let r0 = r24;
            while (r0 !== 0) {
              const r41 = r34.square().mod(a0);
              const isUnit = r41.isUnit();
              const r1 = r0;
              if (isUnit) {
                return false;
              }
              if (r41.equals(r12)) {
                break L12;
              }
              r0 = r1 - 1;
              r34 = r41;
            }
            return false;
          }
        }
      }
      r25 = r29 + 1;
    } while (r25 < a1.length);
  }
  return true;
};
bitwise = function bitwise(a0, a1, a2) {
  "use strict";
  let r24;
  const r8 = parseValue(a1);
  const isNegative = a0.isNegative();
  const isNegative2 = r8.isNegative();
  const r13 = isNegative ? a0.not() : a0;
  const r14 = isNegative2 ? r8.not() : r8;
  L12: {
    r24 = [];
    const isZero = r13.isZero();
    let r12 = r14;
    let r11 = r13;
    if (isZero) {
      const isZero2 = r14.isZero();
      r12 = r14;
      r11 = r13;
      if (isZero2) {
        break L12;
      }
    }
    while (true) {
      const r30 = divModAny(r11, c35_19);
      const r32 = r30[1].toJSNumber();
      const r33 = r12;
      const r16 = isNegative ? c35_19 - 1 - r32 : r32;
      const r34 = divModAny(r33, c35_19);
      const r37 = r34[1].toJSNumber();
      const r38 = isNegative2 ? c35_19 - 1 - r37 : r37;
      const r40 = r30[0];
      const r41 = r34[0];
      r24.push(a2(r16, r38));
      const isZero3 = r40.isZero();
      r12 = r41;
      r11 = r40;
      if (isZero3) {
        const isZero4 = r41.isZero();
        r12 = r41;
        r11 = r40;
        if (isZero4) {
          break;
        }
      }
    }
  }
  const r53 = a2(isNegative ? 1 : 0, isNegative2 ? 1 : 0) !== 0 ? (0, env34[0])(-1) : (0, env34[0])(0);
  let r58 = r24.length - 1;
  let r60 = r53;
  let r61 = r60;
  while (0 <= r58) {
    r60 = r60.multiply(c35_19).add((0, env34[0])(r24[r58]));
    r58 = r58 - 1;
    r61 = r60;
  }
  return r61;
};
integerLogarithm = function integerLogarithm(a0, a1) {
  "use strict";
  if (a1.compareTo(a0) <= 0) {
    const r16 = integerLogarithm(a0, a1.square(a1));
    const { p: r17, e: r5 } = r16;
    const r19 = r17.multiply(a1);
    return r19.compareTo(a0) <= 0 ? {
      p: r19,
      e: 2 * r5 + 1
    } : {
      p: r17,
      e: 2 * r5
    };
  }
  return {
    p: (0, env34[0])(1),
    e: 0
  };
};
gcd = function gcd(a0, a1) {
  "use strict";
  let isEven4, isEven6, isEven8;
  const r23 = parseValue(a0).abs();
  const r27 = parseValue(a1).abs();
  if (r23.equals(r27)) {
    return r23;
  }
  if (r23.isZero()) {
    return r27;
  }
  if (r27.isZero()) {
    return r23;
  }
  const r16 = Integer[1];
  const isEven = r23.isEven();
  let r10 = r16;
  let r14 = r27;
  let r8 = r23;
  if (isEven) {
    const isEven2 = r27.isEven();
    let r12 = r16;
    let r11 = r27;
    let r9 = r23;
    r10 = r12;
    r14 = r11;
    r8 = r9;
    if (isEven2) {
      do {
        const value = r9.value;
        const r19 = r12;
        const r17 = r11;
        const r40 = r9;
        const r42 = typeof value === "number" ? value | c35_21 : typeof value === "bigint" ? value | BigInt(c35_21) : value[0] + value[1] * 10000000 | 1073758208;
        const r47 = r42 & -r42;
        const value2 = r17.value;
        const r52 = typeof value2 === "number" ? value2 | c35_21 : typeof value2 === "bigint" ? value2 | BigInt(c35_21) : value2[0] + value2[1] * 10000000 | 1073758208;
        const r58 = r52 & -r52;
        const r60 = parseValue(r47);
        let r61 = parseValue(r58);
        if (r60.lesser(r61)) {
          r61 = r60;
        }
        const r65 = r40.divide(r61);
        const r67 = r17.divide(r61);
        const r69 = r19.multiply(r61);
        const isEven3 = r65.isEven();
        r10 = r69;
        r14 = r67;
        r8 = r65;
        if (!isEven3) {
          break;
        }
        isEven4 = r67.isEven();
        r12 = r69;
        r11 = r67;
        r9 = r65;
        r10 = r12;
        r14 = r11;
        r8 = r9;
      } while (isEven4);
    }
  }
  const isEven5 = r8.isEven();
  let r79 = r8;
  let r80 = r14;
  let r81 = r79;
  if (isEven5) {
    do {
      const { divide, value: value3 } = r79;
      const r84 = r79;
      const r89 = typeof value3 === "number" ? value3 | c35_21 : typeof value3 === "bigint" ? value3 | BigInt(c35_21) : value3[0] + value3[1] * 10000000 | 1073758208;
      const r96 = divide.call(r84, r89 & -r89);
      isEven6 = r96.isEven();
      r79 = r96;
      r80 = r14;
      r81 = r79;
    } while (isEven6);
  }
  while (true) {
    const isEven7 = r80.isEven();
    let r101 = r80;
    const r102 = r81;
    let r103 = r101;
    if (isEven7) {
      do {
        const { divide: divide2, value: value4 } = r101;
        const r106 = r101;
        const r111 = typeof value4 === "number" ? value4 | c35_21 : typeof value4 === "bigint" ? value4 | BigInt(c35_21) : value4[0] + value4[1] * 10000000 | 1073758208;
        const r118 = divide2.call(r106, r111 & -r111);
        isEven8 = r118.isEven();
        r101 = r118;
        r103 = r101;
      } while (isEven8);
    }
    const r122 = r102.greater(r103);
    let r123 = r103;
    let r124 = r102;
    if (r122) {
      r123 = r102;
      r124 = r103;
    }
    const r126 = r123.subtract(r124);
    const isZero = r126.isZero();
    r80 = r126;
    r81 = r124;
    if (isZero) {
      return r10.isUnit() ? r124 : r124.multiply(r10);
    }
  }
};
toBase = function toBase(a0, a1) {
  "use strict";
  let r7, r8;
  const r9 = (0, env34[0])(a1);
  if (r9.isZero()) {
    if (a0.isZero()) {
      return {
        value: [0],
        isNegative: false
      };
    }
    throw new Error("Cannot convert nonzero numbers to base 0.");
  }
  if (r9.equals(-1)) {
    if (a0.isZero()) {
      return {
        value: [0],
        isNegative: false
      };
    }
    if (a0.isNegative()) {
      return {
        value: [].concat.apply([], Array.apply(null, Array(-a0.toJSNumber())).map(Array.prototype.valueOf, [1, 0])),
        isNegative: false
      };
    }
    const r98 = Array.apply(null, Array(a0.toJSNumber() - 1)).map(Array.prototype.valueOf, [0, 1]);
    r98.unshift([1]);
    return {
      value: [].concat.apply([], r98),
      isNegative: false
    };
  }
  const r24 = a0.isNegative() && r9.isPositive();
  let isNegative4 = false;
  let r11 = a0;
  if (r24) {
    r11 = a0.abs();
    isNegative4 = true;
  }
  if (r9.isUnit()) {
    return r11.isZero() ? {
      value: [0],
      isNegative: false
    } : {
      value: Array.apply(null, Array(r11.toJSNumber())).map(Number.prototype.valueOf, 1),
      isNegative: isNegative4
    };
  }
  L13: {
    r7 = [];
    const isNegative = r11.isNegative();
    let r31 = r11;
    if (!isNegative) {
      const r33 = r11.compareAbs(r9);
      r31 = r11;
      r8 = r31;
      if (!(r33 >= 0)) {
        break L13;
      }
    }
    while (true) {
      const r36 = r31.divmod(r9);
      const { quotient, remainder } = r36;
      const isNegative2 = remainder.isNegative();
      let r13 = remainder;
      let r10 = quotient;
      if (isNegative2) {
        r13 = r9.minus(remainder).abs();
        r10 = quotient.next();
      }
      r7.push(r13.toJSNumber());
      const isNegative3 = r10.isNegative();
      r31 = r10;
      if (!isNegative3) {
        const r50 = r10.compareAbs(r9);
        r31 = r10;
        r8 = r31;
        if (!(r50 >= 0)) {
          break;
        }
      }
    }
  }
  r7.push(r8.toJSNumber());
  return {
    value: r7.reverse(),
    isNegative: isNegative4
  };
};
parseStringValue = function parseStringValue(a0) {
  "use strict";
  let r94, r157;
  const r2 = +a0;
  let r6 = -9007199254740992 < r2;
  if (-9007199254740992 < r2) {
    r6 = r2 < 9007199254740992;
  }
  if (r6) {
    const value3 = +a0;
    if (value3 === (0 < value3 ? Math.floor(value3) : Math.ceil(value3))) {
      if (c35_2) {
        const value4 = BigInt(value3);
        const r166 = {
          __proto__: NativeBigInt.prototype
        };
        r166.value = value4;
        r157 = r166;
      } else {
        r157 = {
          __proto__: SmallInteger.prototype
        };
        r157.value = value3;
        r157.sign = value3 < 0;
        r157.isSmall = true;
      }
      return r157;
    }
    throw new Error("Invalid integer: " + a0);
  }
  const sign = a0[0] === "-";
  let r12 = sign ? a0.slice(1) : a0;
  const r14 = r12.split(/e/i);
  if (r14.length > 2) {
    throw new Error("Invalid integer: " + r14.join("e"));
  }
  L20: {
    if (r14.length === 2) {
      const r15 = r14[1];
      const r33 = +(r15[0] === "+" ? r15.slice(1) : r15);
      if (r33 === (0 < r33 ? Math.floor(r33) : Math.ceil(r33))) {
        let r7 = -9007199254740992 < r33;
        if (-9007199254740992 < r33) {
          r7 = r33 < 9007199254740992;
        }
        if (r7) {
          const r18 = r14[0];
          const r45 = r18.indexOf(".");
          let r46 = r18;
          let r47 = r33;
          if (r45 >= 0) {
            r47 = r33 - (r18.length - r45 - 1);
            r46 = r18.slice(0, r45) + r18.slice(r45 + 1);
          }
          if (r47 < 0) {
            throw new Error("Cannot include negative exponent part for integers");
          }
          r12 = r46 + new Array(r47 + 1).join("0");
          break L20;
        }
      }
      throw new Error("Invalid integer: " + r33 + " is not a valid exponent.");
    }
  }
  const r66 = /^([0-9][0-9]*)$/.test(r12);
  const r67 = r12;
  if (r66) {
    if (c35_2) {
      const value2 = BigInt(sign ? "-" + r67 : r67);
      const r108 = {
        __proto__: NativeBigInt.prototype
      };
      r108.value = value2;
      return r108;
    }
    const value = [];
    let length2 = r67.length;
    let r80 = length2 - 7;
    if (length2 > 0) {
      do {
        value.push(+r67.slice(r80, length2));
        let r0 = r80 - 7;
        if (r0 < 0) {
          r0 = 0;
        }
        length2 = length2 - 7;
        r80 = r0;
      } while (0 < length2);
    }
    const r89 = value.length - 1;
    const r90 = value[r89];
    let r91 = r89;
    let r92 = r91;
    if (r90 === 0) {
      do {
        const r93 = r91 - 1;
        r94 = value[r93];
        r91 = r93;
        r92 = r91;
      } while (r94 === 0);
    }
    value.length = r92 + 1;
    const r99 = {
      __proto__: BigInteger.prototype
    };
    r99.value = value;
    r99.sign = sign;
    r99.isSmall = false;
    return r99;
  }
  throw new Error("Invalid integer: " + r67);
};
parseValue = function parseValue(a0) {
  "use strict";
  let r3, r21;
  if (typeof a0 === "number") {
    if (c35_2) {
      const value = BigInt(a0);
      const r44 = {
        __proto__: NativeBigInt.prototype
      };
      r44.value = value;
      r21 = r44;
    } else if (-9007199254740992 < a0 && a0 < 9007199254740992) {
      if (a0 !== (a0 > 0 ? Math.floor(a0) : Math.ceil(a0))) {
        throw new Error(a0 + " is not an integer.");
      }
      const r29 = {
        __proto__: SmallInteger.prototype
      };
      r29.value = a0;
      r29.sign = a0 < 0;
      r29.isSmall = true;
      r21 = r29;
    } else {
      r21 = parseStringValue(a0.toString());
    }
    r3 = r21;
  } else if (typeof a0 === "string") {
    r3 = parseStringValue(a0);
  } else {
    r3 = a0;
    if (typeof a0 === "bigint") {
      const r13 = {
        __proto__: NativeBigInt.prototype
      };
      r13.value = a0;
      r3 = r13;
    }
  }
  return r3;
};
c35_0 = [4740992, Math.floor(900719925.4740992) % 10000000, Math.floor(90.07199254740992)];
c35_1 = "0123456789abcdefghijklmnopqrstuvwxyz";
c35_2 = typeof globalThis.BigInt === "function";
BigInteger.prototype = Object.create(Integer.prototype);
SmallInteger.prototype = Object.create(Integer.prototype);
NativeBigInt.prototype = Object.create(Integer.prototype);
BigInteger.prototype.add = function(a0) {
  "use strict";
  let r30;
  const r23 = parseValue(a0);
  if (this.sign !== r23.sign) {
    return this.subtract(r23.negate());
  }
  const value2 = this.value;
  const { value, isSmall } = r23;
  if (isSmall) {
    const r34 = Math.abs(value);
    const length2 = value2.length;
    const array = new Array(length2);
    const r39 = 0 < length2;
    let r1 = 0;
    let r40 = r34;
    let r41 = 0;
    let r42 = r40;
    if (r39) {
      do {
        const r18 = value2[r1] - 10000000 + r40;
        const r45 = Math.floor(r18 / 10000000);
        array[r1] = r18 - r45 * 10000000;
        r40 = r45 + 1;
        r1 = r1 + 1;
        r42 = r40;
        r41 = r1;
      } while (r41 < length2);
    }
    while (r42 > 0) {
      const r48 = r41 + 1;
      array[r41] = r42 % 10000000;
      r42 = Math.floor(r42 / 10000000);
      r41 = r48;
    }
    const sign2 = this.sign;
    const r55 = {
      __proto__: BigInteger.prototype
    };
    r55.value = array;
    r55.sign = sign2;
    r55.isSmall = false;
    r30 = r55;
  } else {
    const value3 = addAny(value2, value);
    const sign = this.sign;
    r30 = {
      __proto__: BigInteger.prototype
    };
    r30.value = value3;
    r30.sign = sign;
    r30.isSmall = false;
  }
  return r30;
};
BigInteger.prototype.plus = BigInteger.prototype.add;
SmallInteger.prototype.add = function(a0) {
  "use strict";
  const r11 = parseValue(a0);
  const value = this.value;
  if (value < 0 !== r11.sign) {
    return this.subtract(r11.negate());
  }
  const { value: value2, isSmall } = r11;
  let r19 = value2;
  if (isSmall) {
    const r29 = value + value2;
    if (-9007199254740992 < r29 && r29 < 9007199254740992) {
      const value3 = value + value2;
      const r82 = {
        __proto__: SmallInteger.prototype
      };
      r82.value = value3;
      r82.sign = value3 < 0;
      r82.isSmall = true;
      return r82;
    }
    const r15 = Math.abs(value2);
    r19 = r15 < 10000000 ? [r15] : r15 < 100000000000000 ? [r15 % 10000000, Math.floor(r15 / 10000000)] : [r15 % 10000000, Math.floor(r15 / 10000000) % 10000000, Math.floor(r15 / 100000000000000)];
  }
  const r54 = Math.abs(value);
  const length2 = r19.length;
  const array = new Array(length2);
  const r59 = 0 < length2;
  let r1 = 0;
  let r62 = r54;
  let r63 = 0;
  let r64 = r62;
  if (r59) {
    do {
      const r21 = r19[r1] - 10000000 + r62;
      const r67 = Math.floor(r21 / 10000000);
      array[r1] = r21 - r67 * 10000000;
      r62 = r67 + 1;
      r1 = r1 + 1;
      r64 = r62;
      r63 = r1;
    } while (r63 < length2);
  }
  while (r64 > 0) {
    const r70 = r63 + 1;
    array[r63] = r64 % 10000000;
    r64 = Math.floor(r64 / 10000000);
    r63 = r70;
  }
  const sign = value < 0;
  const r77 = {
    __proto__: BigInteger.prototype
  };
  r77.value = array;
  r77.sign = sign;
  r77.isSmall = false;
  return r77;
};
SmallInteger.prototype.plus = SmallInteger.prototype.add;
NativeBigInt.prototype.add = function(a0) {
  "use strict";
  const value = this.value + parseValue(a0).value;
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
BigInteger.prototype.subtract = function(a0) {
  "use strict";
  let r2, r34, r40, sign2;
  const r16 = parseValue(a0);
  if (this.sign !== r16.sign) {
    return this.add(r16.negate());
  }
  const value = this.value;
  const value2 = r16.value;
  if (r16.isSmall) {
    r40 = subtractSmall(value, Math.abs(value2), this.sign);
  } else {
    const sign = this.sign;
    if (value.length !== value2.length) {
      r2 = value.length > value2.length ? 1 : -1;
    } else {
      let r0 = value.length - 1;
      r2 = 0;
      while (0 <= r0) {
        const r22 = value[r0];
        const r23 = value2[r0];
        const r1 = r0;
        if (r22 !== r23) {
          r2 = value[r1] > value2[r1] ? 1 : -1;
          break;
        }
        r0 = r1 - 1;
        r2 = 0;
      }
    }
    if (0 <= r2) {
      r34 = subtract(value, value2);
      sign2 = sign;
    } else {
      r34 = subtract(value2, value);
      sign2 = !sign;
    }
    const value3 = arrayToSmall(r34);
    if (typeof value3 === "number") {
      const value4 = sign2 ? -value3 : value3;
      const r45 = {
        __proto__: SmallInteger.prototype
      };
      r45.value = value4;
      r45.sign = value4 < 0;
      r45.isSmall = true;
      r40 = r45;
    } else {
      r40 = {
        __proto__: BigInteger.prototype
      };
      r40.value = value3;
      r40.sign = sign2;
      r40.isSmall = false;
    }
  }
  return r40;
};
BigInteger.prototype.minus = BigInteger.prototype.subtract;
SmallInteger.prototype.subtract = function(a0) {
  "use strict";
  let r18;
  const r5 = parseValue(a0);
  const value = this.value;
  if (value < 0 !== r5.sign) {
    return this.add(r5.negate());
  }
  const value2 = r5.value;
  if (r5.isSmall) {
    const value3 = value - value2;
    const r22 = {
      __proto__: SmallInteger.prototype
    };
    r22.value = value3;
    r22.sign = value3 < 0;
    r22.isSmall = true;
    r18 = r22;
  } else {
    r18 = subtractSmall(value2, Math.abs(value), value >= 0);
  }
  return r18;
};
SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
NativeBigInt.prototype.subtract = function(a0) {
  "use strict";
  const value = this.value - parseValue(a0).value;
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;
BigInteger.prototype.negate = function() {
  "use strict";
  const value = this.value;
  const sign = !this.sign;
  const r7 = {
    __proto__: BigInteger.prototype
  };
  r7.value = value;
  r7.sign = sign;
  r7.isSmall = false;
  return r7;
};
SmallInteger.prototype.negate = function() {
  "use strict";
  const sign = this.sign;
  const value = -this.value;
  const r9 = {
    __proto__: SmallInteger.prototype
  };
  r9.value = value;
  r9.sign = value < 0;
  r9.isSmall = true;
  r9.sign = !sign;
  return r9;
};
NativeBigInt.prototype.negate = function() {
  "use strict";
  const value = -this.value;
  const r6 = {
    __proto__: NativeBigInt.prototype
  };
  r6.value = value;
  return r6;
};
BigInteger.prototype.abs = function() {
  "use strict";
  const value = this.value;
  const r6 = {
    __proto__: BigInteger.prototype
  };
  r6.value = value;
  r6.sign = false;
  r6.isSmall = false;
  return r6;
};
SmallInteger.prototype.abs = function() {
  "use strict";
  const value = Math.abs(this.value);
  const r11 = {
    __proto__: SmallInteger.prototype
  };
  r11.value = value;
  r11.sign = value < 0;
  r11.isSmall = true;
  return r11;
};
NativeBigInt.prototype.abs = function() {
  "use strict";
  const value = this.value >= 0 ? this.value : -this.value;
  const r8 = {
    __proto__: NativeBigInt.prototype
  };
  r8.value = value;
  return r8;
};
BigInteger.prototype.multiply = function(a0) {
  "use strict";
  let r63;
  const r24 = parseValue(a0);
  const value2 = this.value;
  const value = r24.value;
  const sign = this.sign !== r24.sign;
  const isSmall = r24.isSmall;
  let r28 = value;
  if (isSmall) {
    if (value === 0) {
      return Integer[0];
    }
    if (value === 1) {
      return this;
    }
    if (value === -1) {
      return this.negate();
    }
    const r16 = Math.abs(value);
    if (r16 < 10000000) {
      const length4 = value2.length;
      const array = new Array(length4);
      const r76 = 0 < length4;
      let r77 = 0;
      let r78 = 0;
      let r79 = 0;
      let r80 = 0;
      if (r76) {
        do {
          const r19 = value2[r78] * r16 + r77;
          const r84 = Math.floor(r19 / 10000000);
          array[r78] = r19 - r84 * 10000000;
          r78 = r78 + 1;
          r77 = r84;
          r79 = r77;
          r80 = r78;
        } while (r80 < length4);
      }
      while (r79 > 0) {
        const r87 = r80 + 1;
        array[r80] = r79 % 10000000;
        r79 = Math.floor(r79 / 10000000);
        r80 = r87;
      }
      const r93 = {
        __proto__: BigInteger.prototype
      };
      r93.value = array;
      r93.sign = sign;
      r93.isSmall = false;
      return r93;
    }
    r28 = r16 < 10000000 ? [r16] : r16 < 100000000000000 ? [r16 % 10000000, Math.floor(r16 / 10000000)] : [r16 % 10000000, Math.floor(r16 / 10000000) % 10000000, Math.floor(r16 / 100000000000000)];
  }
  const length2 = value2.length;
  const length3 = r28.length;
  if (0 < -0.012 * length2 - 0.012 * length3 + 0.000015 * length2 * length3) {
    const value4 = multiplyKaratsuba(value2, r28);
    const r68 = {
      __proto__: BigInteger.prototype
    };
    r68.value = value4;
    r68.sign = sign;
    r68.isSmall = false;
    r63 = r68;
  } else {
    const value3 = multiplyLong(value2, r28);
    r63 = {
      __proto__: BigInteger.prototype
    };
    r63.value = value3;
    r63.sign = sign;
    r63.isSmall = false;
  }
  return r63;
};
BigInteger.prototype.times = BigInteger.prototype.multiply;
SmallInteger.prototype._multiplyBySmall = function(a0) {
  "use strict";
  let r44;
  const r15 = a0.value * this.value;
  if (-9007199254740992 < r15 && r15 < 9007199254740992) {
    const value = a0.value * this.value;
    const r50 = {
      __proto__: SmallInteger.prototype
    };
    r50.value = value;
    r50.sign = value < 0;
    r50.isSmall = true;
    r44 = r50;
  } else {
    const r19 = Math.abs(a0.value);
    const r22 = Math.abs(this.value);
    r44 = multiplySmallAndArray(r19, r22 < 10000000 ? [r22] : r22 < 100000000000000 ? [r22 % 10000000, Math.floor(r22 / 10000000)] : [r22 % 10000000, Math.floor(r22 / 10000000) % 10000000, Math.floor(r22 / 100000000000000)], this.sign !== a0.sign);
  }
  return r44;
};
BigInteger.prototype._multiplyBySmall = function(a0) {
  "use strict";
  return a0.value === 0 ? Integer[0] : a0.value !== 1 ? a0.value === -1 ? this.negate() : multiplySmallAndArray(Math.abs(a0.value), this.value, this.sign !== a0.sign) : this;
};
SmallInteger.prototype.multiply = function(a0) {
  "use strict";
  return parseValue(a0)._multiplyBySmall(this);
};
SmallInteger.prototype.times = SmallInteger.prototype.multiply;
NativeBigInt.prototype.multiply = function(a0) {
  "use strict";
  const value = this.value * parseValue(a0).value;
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
BigInteger.prototype.square = function() {
  "use strict";
  const value = square(this.value);
  const r9 = {
    __proto__: BigInteger.prototype
  };
  r9.value = value;
  r9.sign = false;
  r9.isSmall = false;
  return r9;
};
SmallInteger.prototype.square = function() {
  "use strict";
  let r39;
  const value = this.value * this.value;
  if (-9007199254740992 < value && value < 9007199254740992) {
    const r43 = {
      __proto__: SmallInteger.prototype
    };
    r43.value = value;
    r43.sign = value < 0;
    r43.isSmall = true;
    r39 = r43;
  } else {
    const r18 = Math.abs(this.value);
    const value2 = square(r18 < 10000000 ? [r18] : r18 < 100000000000000 ? [r18 % 10000000, Math.floor(r18 / 10000000)] : [r18 % 10000000, Math.floor(r18 / 10000000) % 10000000, Math.floor(r18 / 100000000000000)]);
    r39 = {
      __proto__: BigInteger.prototype
    };
    r39.value = value2;
    r39.sign = false;
    r39.isSmall = false;
  }
  return r39;
};
NativeBigInt.prototype.square = function(a0) {
  "use strict";
  const value = this.value * this.value;
  const r7 = {
    __proto__: NativeBigInt.prototype
  };
  r7.value = value;
  return r7;
};
BigInteger.prototype.divmod = function(a0) {
  "use strict";
  const r5 = divModAny(this, a0);
  return {
    quotient: r5[0],
    remainder: r5[1]
  };
};
const prototype4 = NativeBigInt.prototype;
const prototype5 = SmallInteger.prototype;
const divmod = BigInteger.prototype.divmod;
prototype5.divmod = divmod;
prototype4.divmod = divmod;
BigInteger.prototype.divide = function(a0) {
  "use strict";
  return divModAny(this, a0)[0];
};
const { prototype: prototype6, prototype: prototype7 } = NativeBigInt;
const divide2 = function(a0) {
  "use strict";
  const value = this.value / parseValue(a0).value;
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
prototype7.divide = divide2;
prototype6.over = divide2;
const { prototype: prototype8, prototype: prototype9 } = SmallInteger;
const prototype = BigInteger.prototype;
const divide = BigInteger.prototype.divide;
prototype.over = divide;
prototype9.divide = divide;
prototype8.over = divide;
BigInteger.prototype.mod = function(a0) {
  "use strict";
  return divModAny(this, a0)[1];
};
const { prototype: prototype10, prototype: prototype11 } = NativeBigInt;
const remainder = function(a0) {
  "use strict";
  const value = this.value % parseValue(a0).value;
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
prototype11.remainder = remainder;
prototype10.mod = remainder;
const { prototype: prototype12, prototype: prototype13 } = SmallInteger;
const prototype14 = BigInteger.prototype;
const mod = BigInteger.prototype.mod;
prototype14.remainder = mod;
prototype13.mod = mod;
prototype12.remainder = mod;
BigInteger.prototype.pow = function(a0) {
  "use strict";
  let r13 = this;
  const r24 = parseValue(a0);
  const value = this.value;
  const value2 = r24.value;
  if (value2 === 0) {
    return Integer[1];
  }
  if (value === 0) {
    return Integer[0];
  }
  if (value === 1) {
    return Integer[1];
  }
  if (value === -1) {
    const isEven = r24.isEven();
    return isEven ? Integer[1] : Integer[-1];
  }
  if (r24.sign) {
    return Integer[0];
  }
  if (r24.isSmall) {
    if (this.isSmall) {
      const r38 = Math.pow(value, value2);
      if (-9007199254740992 < r38 && r38 < 9007199254740992) {
        const value3 = r38 > 0 ? Math.floor(r38) : Math.ceil(r38);
        const r60 = {
          __proto__: SmallInteger.prototype
        };
        r60.value = value3;
        r60.sign = value3 < 0;
        r60.isSmall = true;
        return r60;
      }
    }
    const r18 = Integer[1];
    const r43 = true & value2;
    let r44 = value2;
    let r45 = r18;
    if (r43) {
      r45 = r18.times(this);
      r44 = value2 - 1;
    }
    let r48 = r45;
    let r49 = r48;
    while (r44 !== 0) {
      const r1 = r44 / 2;
      const r51 = r13.square();
      const r4 = true & r1;
      const r20 = r48;
      let r0 = r1;
      let r52 = r20;
      if (r4) {
        r52 = r20.times(r51);
        r0 = r1 - 1;
      }
      r44 = r0;
      r48 = r52;
      r13 = r51;
      r49 = r48;
    }
    return r49;
  }
  throw new Error("The exponent " + r24.toString() + " is too large.");
};
SmallInteger.prototype.pow = BigInteger.prototype.pow;
NativeBigInt.prototype.pow = function(a0) {
  "use strict";
  let r6 = this;
  const r17 = parseValue(a0);
  const value2 = this.value;
  const value = r17.value;
  const value3 = BigInt(0);
  const r10 = BigInt(1);
  const r23 = BigInt(2);
  if (value === value3) {
    return Integer[1];
  }
  if (value2 === value3) {
    return Integer[0];
  }
  if (value2 === r10) {
    return Integer[1];
  }
  if (value2 === BigInt(-1)) {
    const isEven = r17.isEven();
    return isEven ? Integer[1] : Integer[-1];
  }
  if (r17.isNegative()) {
    const r41 = {
      __proto__: NativeBigInt.prototype
    };
    r41.value = value3;
    return r41;
  }
  const r12 = Integer[1];
  const r11 = value & r10;
  let r30 = r12;
  let r31 = value;
  if (r11 === r10) {
    r30 = r12.times(this);
    r31 = value - 1;
  }
  let r33 = r30;
  let r34 = r33;
  while (r31 !== value3) {
    const r14 = r31 / r23;
    const r13 = r6.square();
    const r15 = r14 & r10;
    const r16 = r33;
    let r36 = r16;
    let r37 = r14;
    if (r15 === r10) {
      r36 = r16.times(r13);
      r37 = r14 - 1;
    }
    r33 = r36;
    r31 = r37;
    r6 = r13;
    r34 = r33;
  }
  return r34;
};
BigInteger.prototype.modPow = function(a0, a1) {
  "use strict";
  let isPositive2;
  const r10 = parseValue(a0);
  const r8 = parseValue(a1);
  if (r8.isZero()) {
    throw new Error("Cannot take modPow with modulus 0");
  }
  const r19 = Integer[1];
  const r9 = this.mod(r8);
  const isNegative = r10.isNegative();
  let r7 = r9;
  let r22 = r10;
  if (isNegative) {
    r22 = r10.multiply(Integer[-1]);
    r7 = r9.modInv(r8);
  }
  const isPositive = r22.isPositive();
  let r29 = r22;
  let r30 = r19;
  let r31 = r30;
  if (isPositive) {
    do {
      const isZero = r7.isZero();
      const r11 = r7;
      const r12 = r30;
      const r34 = r29;
      if (isZero) {
        return Integer[0];
      }
      const r37 = r34.isOdd() ? r12.multiply(r11).mod(r8) : r12;
      const r42 = r34.divide(2);
      r7 = r11.square().mod(r8);
      isPositive2 = r42.isPositive();
      r30 = r37;
      r29 = r42;
      r31 = r30;
    } while (isPositive2);
  }
  return r31;
};
const prototype15 = NativeBigInt.prototype;
const prototype16 = SmallInteger.prototype;
const modPow = BigInteger.prototype.modPow;
prototype16.modPow = modPow;
prototype15.modPow = modPow;
BigInteger.prototype.compareAbs = function(a0) {
  "use strict";
  let r2;
  const r10 = parseValue(a0);
  const value = this.value;
  const { value: value2, isSmall } = r10;
  let r5 = 1;
  if (!isSmall) {
    if (value.length !== value2.length) {
      r2 = value.length > value2.length ? 1 : -1;
    } else {
      let r0 = value.length - 1;
      r2 = 0;
      while (0 <= r0) {
        const r19 = value[r0];
        const r20 = value2[r0];
        const r1 = r0;
        if (r19 !== r20) {
          r2 = value[r1] > value2[r1] ? 1 : -1;
          break;
        }
        r0 = r1 - 1;
        r2 = 0;
      }
    }
    r5 = r2;
  }
  return r5;
};
SmallInteger.prototype.compareAbs = function(a0) {
  "use strict";
  const r7 = parseValue(a0);
  const r14 = Math.abs(this.value);
  const { value, isSmall } = r7;
  let r0 = -1;
  let r2 = -1;
  if (isSmall) {
    const r19 = Math.abs(value);
    let r1 = 0;
    if (r14 !== r19) {
      if (r14 > r19) {
        r0 = 1;
      }
      r1 = r0;
    }
    r2 = r1;
  }
  return r2;
};
NativeBigInt.prototype.compareAbs = function(a0) {
  "use strict";
  const value = this.value;
  const value2 = parseValue(a0).value;
  let r11 = value;
  if (!(r11 >= 0)) {
    r11 = -value;
  }
  let r12 = value2;
  if (!(r12 >= 0)) {
    r12 = -value2;
  }
  return r11 !== r12 ? r11 > r12 ? 1 : -1 : 0;
};
BigInteger.prototype.compare = function(a0) {
  "use strict";
  let r2, r34;
  if (a0 === Infinity) {
    return -1;
  }
  if (a0 === -Infinity) {
    return 1;
  }
  const r15 = parseValue(a0);
  const value = this.value;
  const value2 = r15.value;
  if (this.sign !== r15.sign) {
    r34 = r15.sign ? 1 : -1;
  } else if (r15.isSmall) {
    r34 = this.sign ? -1 : 1;
  } else {
    if (value.length !== value2.length) {
      r2 = value.length > value2.length ? 1 : -1;
    } else {
      let r0 = value.length - 1;
      r2 = 0;
      while (0 <= r0) {
        const r21 = value[r0];
        const r22 = value2[r0];
        const r23 = r0;
        if (r21 !== r22) {
          r2 = value[r23] > value2[r23] ? 1 : -1;
          break;
        }
        r0 = r23 - 1;
        r2 = 0;
      }
    }
    r34 = r2 * (this.sign ? -1 : 1);
  }
  return r34;
};
BigInteger.prototype.compareTo = BigInteger.prototype.compare;
SmallInteger.prototype.compare = function(a0) {
  "use strict";
  if (a0 === Infinity) {
    return -1;
  }
  if (a0 === -Infinity) {
    return 1;
  }
  const r11 = parseValue(a0);
  const value = this.value;
  const value2 = r11.value;
  return r11.isSmall ? value == value2 ? 0 : value > value2 ? 1 : -1 : value < 0 !== r11.sign ? value < 0 ? -1 : 1 : value < 0 ? 1 : -1;
};
SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
NativeBigInt.prototype.compare = function(a0) {
  "use strict";
  if (a0 === Infinity) {
    return -1;
  }
  if (a0 === -Infinity) {
    return 1;
  }
  const value = this.value;
  const value2 = parseValue(a0).value;
  return value !== value2 ? value > value2 ? 1 : -1 : 0;
};
NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;
BigInteger.prototype.equals = function(a0) {
  "use strict";
  return this.compare(a0) === 0;
};
const { prototype: prototype17, prototype: prototype18 } = NativeBigInt;
const { prototype: prototype19, prototype: prototype2 } = SmallInteger;
const prototype3 = BigInteger.prototype;
const equals = BigInteger.prototype.equals;
prototype3.eq = equals;
prototype2.equals = equals;
prototype19.eq = equals;
prototype18.equals = equals;
prototype17.eq = equals;
BigInteger.prototype.notEquals = function(a0) {
  "use strict";
  return this.compare(a0) !== 0;
};
const { prototype: prototype20, prototype: prototype21 } = NativeBigInt;
const { prototype: prototype22, prototype: prototype23 } = SmallInteger;
const prototype24 = BigInteger.prototype;
const notEquals = BigInteger.prototype.notEquals;
prototype24.neq = notEquals;
prototype23.notEquals = notEquals;
prototype22.neq = notEquals;
prototype21.notEquals = notEquals;
prototype20.neq = notEquals;
BigInteger.prototype.greater = function(a0) {
  "use strict";
  return this.compare(a0) > 0;
};
const { prototype: prototype25, prototype: prototype26 } = NativeBigInt;
const { prototype: prototype27, prototype: prototype28 } = SmallInteger;
const prototype29 = BigInteger.prototype;
const greater = BigInteger.prototype.greater;
prototype29.gt = greater;
prototype28.greater = greater;
prototype27.gt = greater;
prototype26.greater = greater;
prototype25.gt = greater;
BigInteger.prototype.lesser = function(a0) {
  "use strict";
  return this.compare(a0) < 0;
};
const { prototype: prototype30, prototype: prototype31 } = NativeBigInt;
const { prototype: prototype32, prototype: prototype33 } = SmallInteger;
const prototype34 = BigInteger.prototype;
const lesser = BigInteger.prototype.lesser;
prototype34.lt = lesser;
prototype33.lesser = lesser;
prototype32.lt = lesser;
prototype31.lesser = lesser;
prototype30.lt = lesser;
BigInteger.prototype.greaterOrEquals = function(a0) {
  "use strict";
  return this.compare(a0) >= 0;
};
const { prototype: prototype35, prototype: prototype36 } = NativeBigInt;
const { prototype: prototype37, prototype: prototype38 } = SmallInteger;
const prototype39 = BigInteger.prototype;
const greaterOrEquals = BigInteger.prototype.greaterOrEquals;
prototype39.geq = greaterOrEquals;
prototype38.greaterOrEquals = greaterOrEquals;
prototype37.geq = greaterOrEquals;
prototype36.greaterOrEquals = greaterOrEquals;
prototype35.geq = greaterOrEquals;
BigInteger.prototype.lesserOrEquals = function(a0) {
  "use strict";
  return this.compare(a0) <= 0;
};
const { prototype: prototype40, prototype: prototype41 } = NativeBigInt;
const { prototype: prototype42, prototype: prototype43 } = SmallInteger;
const prototype44 = BigInteger.prototype;
const lesserOrEquals = BigInteger.prototype.lesserOrEquals;
prototype44.leq = lesserOrEquals;
prototype43.lesserOrEquals = lesserOrEquals;
prototype42.leq = lesserOrEquals;
prototype41.lesserOrEquals = lesserOrEquals;
prototype40.leq = lesserOrEquals;
BigInteger.prototype.isEven = function() {
  "use strict";
  return !(1 & this.value[0]);
};
SmallInteger.prototype.isEven = function() {
  "use strict";
  return !(1 & this.value);
};
NativeBigInt.prototype.isEven = function() {
  "use strict";
  return (this.value & BigInt(1)) === BigInt(0);
};
BigInteger.prototype.isOdd = function() {
  "use strict";
  return !(1 & ~this.value[0]);
};
SmallInteger.prototype.isOdd = function() {
  "use strict";
  return !(1 & ~this.value);
};
NativeBigInt.prototype.isOdd = function() {
  "use strict";
  return (this.value & BigInt(1)) === BigInt(1);
};
BigInteger.prototype.isPositive = function() {
  "use strict";
  return !this.sign;
};
SmallInteger.prototype.isPositive = function() {
  "use strict";
  return this.value > 0;
};
NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;
BigInteger.prototype.isNegative = function() {
  "use strict";
  return this.sign;
};
SmallInteger.prototype.isNegative = function() {
  "use strict";
  return this.value < 0;
};
NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;
BigInteger.prototype.isUnit = function() {
  "use strict";
  return false;
};
SmallInteger.prototype.isUnit = function() {
  "use strict";
  return Math.abs(this.value) === 1;
};
NativeBigInt.prototype.isUnit = function() {
  "use strict";
  return this.abs().value === BigInt(1);
};
BigInteger.prototype.isZero = function() {
  "use strict";
  return false;
};
SmallInteger.prototype.isZero = function() {
  "use strict";
  return this.value === 0;
};
NativeBigInt.prototype.isZero = function() {
  "use strict";
  return this.value === BigInt(0);
};
BigInteger.prototype.isDivisibleBy = function(a0) {
  "use strict";
  const r5 = parseValue(a0);
  const isZero = r5.isZero();
  return isZero ? !isZero : !!r5.isUnit() || (r5.compareAbs(2) === 0 ? this.isEven() : this.mod(r5).isZero());
};
const prototype45 = NativeBigInt.prototype;
const prototype46 = SmallInteger.prototype;
const isDivisibleBy = BigInteger.prototype.isDivisibleBy;
prototype46.isDivisibleBy = isDivisibleBy;
prototype45.isDivisibleBy = isDivisibleBy;
BigInteger.prototype.isPrime = function(a0) {
  "use strict";
  const r11 = this.abs();
  const isUnit = r11.isUnit();
  let r8 = !isUnit;
  if (!isUnit) {
    let r25 = !!(r11.equals(2) || r11.equals(3) || r11.equals(5));
    if (!r25) {
      const r27 = r11.isEven() || r11.isDivisibleBy(3) || r11.isDivisibleBy(5);
      r25 = r27 ? !r27 : !!r11.lesser(49) || void 0;
    }
    r8 = r25;
  }
  if (r8 !== void 0) {
    return r8;
  }
  const r39 = this.abs();
  const r14 = r39.bitLength();
  if (r14 <= 64) {
    return millerRabinTest(r39, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
  }
  const r17 = Math.log(2) * r14.toJSNumber();
  const r54 = Math.ceil(a0 === true ? 2 * Math.pow(r17, 2) : r17);
  const r55 = [];
  const r57 = 0 < r54;
  let r0 = 0;
  if (r57) {
    do {
      r55.push((0, env34[0])(r0 + 2));
      r0 = r0 + 1;
    } while (r0 < r54);
  }
  return millerRabinTest(r39, r55);
};
const prototype47 = NativeBigInt.prototype;
const prototype48 = SmallInteger.prototype;
const isPrime = BigInteger.prototype.isPrime;
prototype48.isPrime = isPrime;
prototype47.isPrime = isPrime;
BigInteger.prototype.isProbablePrime = function(a0, a1) {
  "use strict";
  const r11 = this.abs();
  const isUnit = r11.isUnit();
  let r7 = !isUnit;
  if (!isUnit) {
    let r26 = !!(r11.equals(2) || r11.equals(3) || r11.equals(5));
    if (!r26) {
      const r28 = r11.isEven() || r11.isDivisibleBy(3) || r11.isDivisibleBy(5);
      r26 = r28 ? !r28 : !!r11.lesser(49) || void 0;
    }
    r7 = r26;
  }
  if (r7 !== void 0) {
    return r7;
  }
  const r40 = this.abs();
  const r41 = a0 !== void 0 ? a0 : 5;
  const r42 = [];
  const r44 = 0 < r41;
  let r0 = 0;
  if (r44) {
    do {
      r42.push(env34[0].randBetween(2, r40.minus(2), a1));
      r0 = r0 + 1;
    } while (r0 < r41);
  }
  return millerRabinTest(r40, r42);
};
const prototype49 = NativeBigInt.prototype;
const prototype50 = SmallInteger.prototype;
const isProbablePrime = BigInteger.prototype.isProbablePrime;
prototype50.isProbablePrime = isProbablePrime;
prototype49.isProbablePrime = isProbablePrime;
BigInteger.prototype.modInv = function(a0) {
  "use strict";
  let isZero2;
  const r17 = env34[0];
  const zero = r17.zero;
  let one = r17.one;
  let r8 = parseValue(a0);
  const r7 = this.abs();
  const isZero = r7.isZero();
  let r9 = r7;
  let r23 = zero;
  let r4 = r8;
  let r24 = r23;
  if (!isZero) {
    do {
      const r12 = r8.divide(r9);
      const r13 = r23.subtract(r12.multiply(one));
      const r14 = r8.subtract(r12.multiply(r9));
      isZero2 = r14.isZero();
      r8 = r9;
      r23 = one;
      r9 = r14;
      one = r13;
      r4 = r8;
      r24 = r23;
    } while (!isZero2);
  }
  if (r4.isUnit()) {
    const r51 = r24.compare(0) === -1 ? r24.add(a0) : r24;
    return this.isNegative() ? r51.negate() : r51;
  }
  throw new Error(this.toString() + " and " + a0.toString() + " are not co-prime");
};
const r294 = NativeBigInt.prototype;
const r295 = SmallInteger.prototype;
const modInv = BigInteger.prototype.modInv;
r295.modInv = modInv;
r294.modInv = modInv;
BigInteger.prototype.next = function() {
  "use strict";
  let r39;
  const value = this.value;
  if (this.sign) {
    r39 = subtractSmall(value, 1, this.sign);
  } else {
    const length2 = value.length;
    const array = new Array(length2);
    const r6 = 0 < length2;
    let r1 = 0;
    let r14 = 1;
    let r2 = 0;
    let r26 = 1;
    if (r6) {
      do {
        const r17 = value[r1] - 10000000 + r14;
        const r29 = Math.floor(r17 / 10000000);
        array[r1] = r17 - r29 * 10000000;
        r14 = r29 + 1;
        r1 = r1 + 1;
        r26 = r14;
        r2 = r1;
      } while (r2 < length2);
    }
    while (r26 > 0) {
      const r32 = r2 + 1;
      array[r2] = r26 % 10000000;
      r26 = Math.floor(r26 / 10000000);
      r2 = r32;
    }
    const sign = this.sign;
    r39 = {
      __proto__: BigInteger.prototype
    };
    r39.value = array;
    r39.sign = sign;
    r39.isSmall = false;
  }
  return r39;
};
SmallInteger.prototype.next = function() {
  "use strict";
  let r10;
  const value = this.value;
  if (value + 1 < 9007199254740992) {
    const value3 = value + 1;
    const r14 = {
      __proto__: SmallInteger.prototype
    };
    r14.value = value3;
    r14.sign = value3 < 0;
    r14.isSmall = true;
    r10 = r14;
  } else {
    const value2 = c35_0;
    r10 = {
      __proto__: BigInteger.prototype
    };
    r10.value = value2;
    r10.sign = false;
    r10.isSmall = false;
  }
  return r10;
};
NativeBigInt.prototype.next = function() {
  "use strict";
  const value = this.value + BigInt(1);
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
BigInteger.prototype.prev = function() {
  "use strict";
  let r24;
  const value = this.value;
  if (this.sign) {
    const length2 = value.length;
    const array = new Array(length2);
    const r6 = 0 < length2;
    let r1 = 0;
    let r12 = 1;
    let r30 = 0;
    let r31 = 1;
    if (r6) {
      do {
        const r16 = value[r1] - 10000000 + r12;
        const r34 = Math.floor(r16 / 10000000);
        array[r1] = r16 - r34 * 10000000;
        r12 = r34 + 1;
        r1 = r1 + 1;
        r31 = r12;
        r30 = r1;
      } while (r30 < length2);
    }
    while (r31 > 0) {
      const r37 = r30 + 1;
      array[r30] = r31 % 10000000;
      r31 = Math.floor(r31 / 10000000);
      r30 = r37;
    }
    const r43 = {
      __proto__: BigInteger.prototype
    };
    r43.value = array;
    r43.sign = true;
    r43.isSmall = false;
    r24 = r43;
  } else {
    r24 = subtractSmall(value, 1, this.sign);
  }
  return r24;
};
SmallInteger.prototype.prev = function() {
  "use strict";
  let r10;
  const value = this.value;
  if (-9007199254740992 < value - 1) {
    const value3 = value - 1;
    const r15 = {
      __proto__: SmallInteger.prototype
    };
    r15.value = value3;
    r15.sign = value3 < 0;
    r15.isSmall = true;
    r10 = r15;
  } else {
    const value2 = c35_0;
    r10 = {
      __proto__: BigInteger.prototype
    };
    r10.value = value2;
    r10.sign = true;
    r10.isSmall = false;
  }
  return r10;
};
NativeBigInt.prototype.prev = function() {
  "use strict";
  const value = this.value - BigInt(1);
  const r11 = {
    __proto__: NativeBigInt.prototype
  };
  r11.value = value;
  return r11;
};
c35_17 = [1];
while (2 * c35_17[c35_17.length - 1] <= 10000000) {
  c35_17.push(2 * c35_17[c35_17.length - 1]);
}
const length2 = c35_17.length;
length = length2;
c35_19 = c35_17[length2 - 1];
BigInteger.prototype.shiftLeft = function(a0) {
  "use strict";
  let r34;
  const r16 = parseValue(a0).toJSNumber();
  if (Math.abs(r16) <= 10000000) {
    if (r16 < 0) {
      return this.shiftRight(-r16);
    }
    if (this.isZero()) {
      return this;
    }
    let r10 = this;
    let r9 = r16;
    let r32 = this;
    let r8 = r9;
    if (r8 >= length) {
      do {
        r10 = r10.multiply(c35_19);
        r34 = length;
        r9 = r9 - (r34 - 1);
        r32 = r10;
        r8 = r9;
      } while (r8 >= r34);
    }
    return r32.multiply(c35_17[r8]);
  }
  throw new Error(String(r16) + " is too large for shifting.");
};
const r330 = NativeBigInt.prototype;
const r331 = SmallInteger.prototype;
const shiftLeft = BigInteger.prototype.shiftLeft;
r331.shiftLeft = shiftLeft;
r330.shiftLeft = shiftLeft;
BigInteger.prototype.shiftRight = function(a0) {
  "use strict";
  let r36;
  const r21 = parseValue(a0).toJSNumber();
  if (Math.abs(r21) <= 10000000) {
    if (r21 < 0) {
      return this.shiftLeft(-r21);
    }
    let r12 = this;
    let r11 = r21;
    let r9 = this;
    let r10 = r11;
    if (r10 >= length) {
      while (true) {
        L15: {
          const isZero = r12.isZero();
          r36 = r12;
          const r14 = r11;
          if (!isZero) {
            if (r36.isNegative() && r36.isUnit()) {
              break L15;
            }
            const r42 = divModAny(r36, c35_19);
            const isNegative = r42[1].isNegative();
            const r45 = r42[0];
            const r46 = isNegative ? r45.prev() : r45;
            r11 = r14 - (length - 1);
            r12 = r46;
            r9 = r12;
            r10 = r11;
            if (r10 >= length) {
              continue;
            }
            break;
          }
        }
        return r36;
      }
    }
    const r52 = divModAny(r9, c35_17[r10]);
    const isNegative2 = r52[1].isNegative();
    const r56 = r52[0];
    return isNegative2 ? r56.prev() : r56;
  }
  throw new Error(String(r21) + " is too large for shifting.");
};
const r336 = NativeBigInt.prototype;
const r337 = SmallInteger.prototype;
const shiftRight = BigInteger.prototype.shiftRight;
r337.shiftRight = shiftRight;
r336.shiftRight = shiftRight;
BigInteger.prototype.not = function() {
  "use strict";
  return this.negate().prev();
};
const r342 = NativeBigInt.prototype;
const r343 = SmallInteger.prototype;
const not = BigInteger.prototype.not;
r343.not = not;
r342.not = not;
BigInteger.prototype.and = function(a0) {
  "use strict";
  return bitwise(this, a0, function(a0, a1) {
    return a0 & a1;
  });
};
const r348 = NativeBigInt.prototype;
const r349 = SmallInteger.prototype;
const and = BigInteger.prototype.and;
r349.and = and;
r348.and = and;
BigInteger.prototype.or = function(a0) {
  "use strict";
  return bitwise(this, a0, function(a0, a1) {
    return a0 | a1;
  });
};
const r354 = NativeBigInt.prototype;
const r355 = SmallInteger.prototype;
const or = BigInteger.prototype.or;
r355.or = or;
r354.or = or;
BigInteger.prototype.xor = function(a0) {
  "use strict";
  return bitwise(this, a0, function(a0, a1) {
    return a0 ^ a1;
  });
};
const r360 = NativeBigInt.prototype;
const r361 = SmallInteger.prototype;
const xor = BigInteger.prototype.xor;
r361.xor = xor;
r360.xor = xor;
c35_21 = 1073741824;
BigInteger.prototype.bitLength = function() {
  "use strict";
  let r27, r33, r66;
  const compareTo = this.compareTo;
  const r6 = env34[0];
  const r16 = compareTo.call(this, r6(0)) < 0 ? this.negate().subtract(r6(1)) : this;
  const r22 = r16.compareTo(r6(0));
  if (r22 === 0) {
    r66 = r6(0);
  } else {
    const r10 = r6(2);
    if (r10.compareTo(r16) <= 0) {
      const r13 = r10.square(r10);
      if (r13.compareTo(r16) <= 0) {
        const r38 = integerLogarithm(r16, r13.square(r13));
        const { p: r39, e: r12 } = r38;
        const r41 = r39.multiply(r13);
        r33 = r41.compareTo(r16) <= 0 ? {
          p: r41,
          e: 2 * r12 + 1
        } : {
          p: r39,
          e: 2 * r12
        };
      } else {
        r33 = {
          p: r6(1),
          e: 0
        };
      }
      const { p: r49, e: r50 } = r33;
      const r52 = r49.multiply(r10);
      r27 = r52.compareTo(r16) <= 0 ? {
        p: r52,
        e: 2 * r50 + 1
      } : {
        p: r49,
        e: 2 * r50
      };
    } else {
      r27 = {
        p: r6(1),
        e: 0
      };
    }
    r66 = r6(r27.e).add(r6(1));
  }
  return r66;
};
const r367 = NativeBigInt.prototype;
const r368 = SmallInteger.prototype;
const bitLength = BigInteger.prototype.bitLength;
r368.bitLength = bitLength;
r367.bitLength = bitLength;
parseBase = function parseBase(a0, a1, a2, a3) {
  "use strict";
};
BigInteger.prototype.toArray = function(a0) {
  "use strict";
  return toBase(this, a0);
};
SmallInteger.prototype.toArray = function(a0) {
  "use strict";
  return toBase(this, a0);
};
NativeBigInt.prototype.toArray = function(a0) {
  "use strict";
  return toBase(this, a0);
};
BigInteger.prototype.toString = function(a0, a1) {
  "use strict";
  const r5 = a0 === void 0 ? 10 : a0;
  if (r5 !== 10) {
    let env23556;
    const r28 = env23556 = {
      $parent: env35
    };
    env23556[0] = a1;
    const r31 = toBase(this, r5);
    return (r31.isNegative ? "-" : "") + r31.value.map($mk100897(r28)).join("");
  }
  const value = this.value;
  const length2 = value.length;
  const r6 = String;
  const r13 = length2 - 1;
  const r14 = r6(value[r13]);
  let r7 = r13 - 1;
  let r17 = r14;
  let r18 = r17;
  while (r7 >= 0) {
    const r19 = String(value[r7]);
    r17 = r17 + ("0000000".slice(r19.length) + r19);
    r7 = r7 - 1;
    r18 = r17;
  }
  return (this.sign ? "-" : "") + r18;
};
SmallInteger.prototype.toString = function(a0, a1) {
  "use strict";
  let r9;
  const r6 = a0 === void 0 ? 10 : a0;
  if (r6 != 10) {
    let env23557;
    const r10 = env23557 = {
      $parent: env35
    };
    env23557[0] = a1;
    const r13 = toBase(this, r6);
    r9 = (r13.isNegative ? "-" : "") + r13.value.map($mk100897(r10)).join("");
  } else {
    r9 = String(this.value);
  }
  return r9;
};
NativeBigInt.prototype.toString = SmallInteger.prototype.toString;
const r385 = NativeBigInt.prototype;
const r386 = BigInteger.prototype;
const r387 = SmallInteger.prototype;
const toJSON = function() {
  "use strict";
  return this.toString();
};
r387.toJSON = toJSON;
r386.toJSON = toJSON;
r385.toJSON = toJSON;
BigInteger.prototype.valueOf = function() {
  "use strict";
  return parseInt(this.toString(), 10);
};
BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
SmallInteger.prototype.valueOf = function() {
  "use strict";
  return this.value;
};
SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
const { prototype: r399, prototype: r400 } = NativeBigInt;
const toJSNumber = function() {
  "use strict";
  return parseInt(this.toString(), 10);
};
r400.toJSNumber = toJSNumber;
r399.valueOf = toJSNumber;
let r404 = 0;
while (true) {
  Integer[r404] = parseValue(r404);
  const r2 = r404;
  if (0 < r2) {
    const r4 = -r2;
    Integer[r4] = parseValue(r4);
  }
  r404 = r2 + 1;
  if (!(r404 < 1000)) {
    const max = function max(a0, a1) {
      "use strict";
      const r2 = parseValue(a0);
      let r6 = parseValue(a1);
      if (r2.greater(r6)) {
        r6 = r2;
      }
      return r6;
    };
    const min = function min(a0, a1) {
      "use strict";
      const r2 = parseValue(a0);
      let r6 = parseValue(a1);
      if (r2.lesser(r6)) {
        r6 = r2;
      }
      return r6;
    };
    Integer.one = Integer[1];
    Integer.zero = Integer[0];
    Integer.minusOne = Integer[-1];
    Integer.max = max;
    Integer.min = min;
    Integer.gcd = gcd;
    Integer.lcm = function lcm(a0, a1) {
      "use strict";
      const r6 = parseValue(a0).abs();
      const r10 = parseValue(a1).abs();
      return r6.divide(gcd(r6, r10)).multiply(r10);
    };
    Integer.isInstance = function(a0) {
      "use strict";
      return a0 instanceof BigInteger || a0 instanceof SmallInteger || a0 instanceof NativeBigInt;
    };
    Integer.randBetween = function randBetween(a0, a1, a2) {
      "use strict";
      let length2;
      let r9 = a2;
      const r12 = parseValue(a0);
      const r13 = parseValue(a1);
      if (!a2) {
        r9 = Math.random;
      }
      const r15 = parseValue(r12);
      let r24 = parseValue(r13);
      if (r15.lesser(r24)) {
        r24 = r15;
      }
      const r26 = parseValue(r12);
      let r27 = parseValue(r13);
      if (r26.greater(r27)) {
        r27 = r26;
      }
      const r33 = r27.subtract(r24).add(1);
      if (r33.isSmall) {
        return r24.add(Math.floor(r9() * r33));
      }
      const value = toBase(r33, 10000000).value;
      const r38 = [];
      const r5 = 0 < value.length;
      let r0 = 0;
      let r6 = true;
      if (r5) {
        do {
          const r1 = r0;
          let r41 = r6;
          const r17 = r41 ? value[r1] : 10000000;
          const r20 = r9() * r17;
          const r44 = r20 > 0 ? Math.floor(r20) : Math.ceil(r20);
          r38.push(r44);
          if (r44 < r17) {
            r41 = false;
          }
          r0 = r1 + 1;
          length2 = value.length;
          r6 = r41;
        } while (r0 < length2);
      }
      return r24.add(Integer.fromArray(r38, 10000000, false));
    };
    Integer.fromArray = function(a0, a1, a2) {
      "use strict";
      let r7 = a1;
      const map = a0.map;
      const r13 = map.call(a0, parseValue);
      if (!a1) {
        r7 = 10;
      }
      const r14 = parseValue(r7);
      const r16 = Integer[0];
      let r17 = Integer[1];
      let r0 = r13.length - 1;
      let r19 = r16;
      let r20 = r19;
      while (0 <= r0) {
        r19 = r19.add(r13[r0].times(r17));
        r17 = r17.times(r14);
        r0 = r0 - 1;
        r20 = r19;
      }
      return a2 ? r20.negate() : r20;
    };
    env34[0] = Integer;
    if (module !== void 0 && module.hasOwnProperty("exports")) {
      module.exports = Integer;
    }
    const define2 = globalThis.define;
    if (typeof define2 === "function" ? define.amd : typeof define2 === "function") {
      define(function() {
        return env34[0];
      });
    }
    return void 0;
  }
}