decord/source/24_Integer.js

// Module ID: 24
// Function ID: 965
// Name: Integer
// Dependencies: []

// Module 24 (Integer)
let tmp = ((arg0) => {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp8 = Integer;
        num2 = 0;
        first = Integer[0];
      } else if (undefined === arg1) {
        tmp = parseValue;
        first = parseValue(arg0);
      } else {
        num = 10;
        if (10 === +arg1) {
        }
        tmp3 = parseBase;
        tmp4 = arg3;
        tmp5 = arg0;
        tmp6 = arg1;
        tmp7 = arg2;
        first = parseBase(arg0, arg1, arg2, arg3);
      }
      return first;
    }
  }
  class BigInteger {
    constructor(arg0, arg1) {
      this.value = arg0;
      this.sign = arg1;
      this.isSmall = false;
      return;
    }
    add(arg0) {
      self = this;
      iter = parseValue(arg0);
      if (this.sign !== iter.sign) {
        return self.subtract(iter.negate());
      } else {
        value = self.value;
        value = iter.value;
        tmp = BigInteger;
        if (iter.isSmall) {
          tmp6 = addSmall;
          tmp7 = globalThis;
          _Math = Math;
          prototype2 = tmp.prototype;
          tmp8 = new.target;
          tmp9 = new.target;
          tmp = new tmp(addSmall(value, Math.abs(value)), self.sign);
        } else {
          tmp2 = addAny;
          prototype = tmp.prototype;
          tmp3 = new.target;
          tmp4 = new.target;
          tmp = new tmp(addAny(value, value), self.sign);
        }
        return tmp;
      }
    }
    subtract(arg0) {
      self = this;
      iter = parseValue(arg0);
      if (this.sign !== iter.sign) {
        return self.add(iter.negate());
      } else {
        value = self.value;
        value = iter.value;
        if (iter.isSmall) {
          tmp19 = subtractSmall;
          tmp20 = globalThis;
          _Math = Math;
          tmp13 = subtractSmall(value, Math.abs(value), self.sign);
        } else {
          sign = self.sign;
          tmp = compareAbs;
          num = 0;
          if (compareAbs(value, value) >= 0) {
            tmp5 = subtract;
            tmp3 = subtract(value, value);
            tmp4 = sign;
          } else {
            tmp2 = subtract;
            tmp3 = subtract(value, value);
            tmp4 = !sign;
          }
          tmp6 = arrayToSmall;
          tmp7 = arrayToSmall(tmp3);
          str = "number";
          if ("number" === typeof tmp7) {
            tmp14 = tmp7;
            if (tmp4) {
              tmp14 = -tmp7;
            }
            tmp15 = SmallInteger;
            prototype2 = SmallInteger.prototype;
            tmp16 = new.target;
            tmp17 = new.target;
            tmp18 = tmp14;
            tmp13 = new SmallInteger(tmp14);
          } else {
            tmp8 = BigInteger;
            prototype = BigInteger.prototype;
            tmp9 = new.target;
            tmp10 = new.target;
            tmp11 = tmp7;
            tmp12 = tmp4;
            tmp13 = new BigInteger(tmp7, tmp4);
          }
        }
        return tmp13;
      }
    }
    negate() {
      tmp = new BigInteger(this.value, !this.sign);
      return tmp;
    }
    abs() {
      tmp = new BigInteger(this.value, false);
      return tmp;
    }
    multiply(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      value = iter.value;
      tmp = this.sign !== iter.sign;
      arr2 = value;
      if (iter.isSmall) {
        num = 0;
        if (0 === value) {
          tmp20 = Integer;
          return Integer[0];
        } else {
          num2 = 1;
          if (1 === value) {
            return self;
          } else {
            num3 = -1;
            if (-1 === value) {
              return self.negate();
            } else {
              tmp21 = globalThis;
              _Math = Math;
              absolute = Math.abs(value);
              num4 = 10000000;
              if (absolute < 10000000) {
                tmp13 = BigInteger;
                tmp14 = multiplySmall;
                prototype3 = BigInteger.prototype;
                tmp15 = new.target;
                tmp16 = new.target;
                tmp17 = tmp;
                tmp18 = new BigInteger(multiplySmall(value, absolute), tmp);
                tmp19 = tmp18;
                return tmp18;
              } else {
                tmp23 = smallToArray;
                arr2 = smallToArray(absolute);
              }
            }
          }
        }
      }
      length = value.length;
      length2 = arr2.length;
      if (-0.012 * length - 0.012 * length2 + 0.000015 * length * length2 > 0) {
        tmp8 = BigInteger;
        tmp9 = multiplyKaratsuba;
        prototype2 = BigInteger.prototype;
        tmp10 = new.target;
        tmp11 = new.target;
        tmp12 = tmp;
        tmp7 = new BigInteger(multiplyKaratsuba(value, arr2), tmp);
      } else {
        tmp2 = BigInteger;
        tmp3 = multiplyLong;
        prototype = BigInteger.prototype;
        tmp4 = new.target;
        tmp5 = new.target;
        tmp6 = tmp;
        tmp7 = new BigInteger(multiplyLong(value, arr2), tmp);
      }
      return tmp7;
    }
    _multiplyBySmall(arg0) {
      self = this;
      if (0 === arg0.value) {
        tmp6 = Integer;
        first = Integer[0];
      } else {
        num = 1;
        first = self;
        if (1 !== arg0.value) {
          num2 = -1;
          if (-1 === arg0.value) {
            negateResult = self.negate();
          } else {
            tmp2 = multiplySmallAndArray;
            tmp3 = globalThis;
            _Math = Math;
            negateResult = multiplySmallAndArray(Math.abs(arg0.value), self.value, self.sign !== arg0.sign);
          }
          tmp5 = negateResult;
        }
      }
      return first;
    }
    square() {
      tmp = new BigInteger(square(this.value), false);
      return tmp;
    }
    divmod(arg0) {
      tmp = divModAny(this, arg0);
      obj = { quotient: tmp[0], remainder: tmp[1] };
      return obj;
    }
    divide(arg0) {
      return divModAny(this, arg0)[0];
    }
    mod(arg0) {
      return divModAny(this, arg0)[1];
    }
    pow(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      value = iter.value;
      if (0 === value) {
        tmp26 = Integer;
        num2 = 1;
        return Integer[1];
      } else if (0 === value) {
        tmp25 = Integer;
        return Integer[0];
      } else {
        num3 = 1;
        if (1 === value) {
          tmp24 = Integer;
          return Integer[1];
        } else {
          num4 = -1;
          if (-1 === value) {
            tmp23 = Integer;
            return iter.isEven() ? tmp23[1] : tmp23[-1];
          } else if (iter.sign) {
            tmp22 = Integer;
            return Integer[0];
          } else if (iter.isSmall) {
            if (self.isSmall) {
              tmp6 = isPrecise;
              tmp7 = globalThis;
              _Math = Math;
              powResult = Math.pow(value, value);
              if (isPrecise(powResult)) {
                tmp16 = SmallInteger;
                tmp17 = truncate;
                prototype2 = SmallInteger.prototype;
                tmp18 = new.target;
                tmp19 = new.target;
                tmp20 = new SmallInteger(truncate(powResult));
                tmp21 = tmp20;
                return tmp20;
              }
            }
            tmp9 = Integer;
            obj = Integer[1];
            flag = true;
            timesResult = obj;
            diff = value;
            if (true & value) {
              timesResult = obj.times(self);
              diff = value - 1;
            }
            num = 2;
            obj2 = self;
            obj3 = timesResult;
            tmp12 = timesResult;
            if (0 !== diff) {
              do {
                result = diff / 2;
                squareResult = obj2.square();
                timesResult1 = obj3;
                diff = result;
                if (true & result) {
                  timesResult1 = obj3.times(squareResult);
                  diff = result - 1;
                }
                obj3 = timesResult1;
                obj2 = squareResult;
                tmp12 = timesResult1;
              } while (0 !== diff);
            }
            return tmp12;
          } else {
            tmp = globalThis;
            _Error = Error;
            str = "The exponent ";
            prototype = Error.prototype;
            tmp2 = new.target;
            str2 = " is too large.";
            tmp3 = new.target;
            error = new Error("The exponent " + iter.toString() + " is too large.");
            tmp5 = error;
            throw error;
          }
        }
      }
    }
    modPow(arg0, arg1) {
      self = this;
      obj = parseValue(arg0);
      obj2 = parseValue(arg1);
      if (obj2.isZero()) {
        tmp8 = globalThis;
        _Error = Error;
        prototype = Error.prototype;
        tmp9 = new.target;
        str = "Cannot take modPow with modulus 0";
        tmp10 = new.target;
        error = new Error("Cannot take modPow with modulus 0");
        tmp12 = error;
        throw error;
      } else {
        tmp = Integer;
        num = 1;
        tmp2 = Integer[1];
        modResult = self.mod(obj2);
        multiplyResult = obj;
        modInvResult = modResult;
        if (obj.isNegative()) {
          tmp3 = Integer;
          num2 = -1;
          multiplyResult = obj.multiply(Integer[-1]);
          modInvResult = modResult.modInv(obj2);
        }
        num3 = 2;
        obj6 = multiplyResult;
        obj7 = tmp2;
        tmp4 = tmp2;
        if (multiplyResult.isPositive()) {
          tmp5 = modInvResult;
          while (!modInvResult.isZero()) {
            modResult1 = obj7;
            if (obj6.isOdd()) {
              multiplyResult1 = obj7.multiply(modInvResult);
              modResult1 = multiplyResult1.mod(obj2);
            }
            divideResult = obj6.divide(2);
            squareResult = modInvResult.square();
            modInvResult = squareResult.mod(obj2);
            obj7 = modResult1;
            obj6 = divideResult;
            tmp4 = modResult1;
          }
          tmp7 = Integer;
          num4 = 0;
          return Integer[0];
        }
        return tmp4;
      }
    }
    compareAbs(arg0) {
      tmp = parseValue(arg0);
      num = 1;
      if (!tmp.isSmall) {
        tmp4 = compareAbs;
        num = compareAbs(tmp2, tmp3);
      }
      return num;
    }
    compare(arg0) {
      self = this;
      if (arg0 === Infinity) {
        num5 = -1;
        return -1;
      } else {
        num6 = -Infinity;
        if (arg0 === -Infinity) {
          num4 = 1;
          return 1;
        } else {
          tmp4 = parseValue;
          tmp5 = parseValue(arg0);
          if (self.sign !== tmp5.sign) {
            num3 = -1;
            if (tmp5.sign) {
              num3 = 1;
            }
            result = num3;
          } else if (tmp5.isSmall) {
            num2 = 1;
            if (self.sign) {
              num2 = -1;
            }
            result = num2;
          } else {
            tmp = compareAbs;
            num = 1;
            tmp2 = compareAbs(tmp6, tmp7);
            if (self.sign) {
              num = -1;
            }
            result = tmp2 * num;
          }
          return result;
        }
      }
    }
    equals(arg0) {
      return 0 === this.compare(arg0);
    }
    notEquals(arg0) {
      return 0 !== this.compare(arg0);
    }
    greater(arg0) {
      return this.compare(arg0) > 0;
    }
    lesser(arg0) {
      return this.compare(arg0) < 0;
    }
    greaterOrEquals(arg0) {
      return this.compare(arg0) >= 0;
    }
    lesserOrEquals(arg0) {
      return this.compare(arg0) <= 0;
    }
    isEven() {
      return !(1 & this.value[0]);
    }
    isOdd() {
      return !(1 & ~this.value[0]);
    }
    isPositive() {
      return !this.sign;
    }
    isNegative() {
      return this.sign;
    }
    isUnit() {
      return false;
    }
    isZero() {
      return false;
    }
    isDivisibleBy(arg0) {
      self = this;
      obj = parseValue(arg0);
      tmp = !obj.isZero();
      if (tmp) {
        tmp2 = !obj.isUnit();
        if (!tmp2) {
          tmp = !tmp2;
        } else {
          num = 2;
          num2 = 0;
          if (0 === obj.compareAbs(2)) {
            isEvenResult = self.isEven();
          } else {
            modResult = self.mod(obj);
            isEvenResult = modResult.isZero();
          }
          tmp4 = isEvenResult;
        }
      }
      return tmp;
    }
    isPrime(arg0) {
      self = this;
      tmp = isBasicPrime(this);
      if (tmp !== closure_0) {
        return tmp;
      } else {
        absResult = self.abs();
        bitLengthResult = absResult.bitLength();
        num2 = 64;
        if (bitLengthResult <= 64) {
          tmp7 = millerRabinTest;
          return millerRabinTest(absResult, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
        } else {
          tmp8 = globalThis;
          _Math2 = Math;
          num3 = 2;
          logResult = Math.log(2);
          result = logResult * bitLengthResult.toJSNumber();
          flag = true;
          tmp11 = arg0;
          result1 = result;
          if (true === arg0) {
            _Math = Math;
            result1 = 2 * Math.pow(result, 2);
          }
          rounded = Math.ceil(result1);
          items = [];
          for (let num = 0; num < rounded; num = num + 1) {
            tmp4 = outer1_0;
            arr = items.push(outer1_0(num + 2));
          }
          tmp6 = millerRabinTest;
          return millerRabinTest(absResult, items);
        }
      }
    }
    isProbablePrime(arg0, arg1) {
      self = this;
      tmp = isBasicPrime(this);
      if (tmp !== closure_0) {
        return tmp;
      } else {
        absResult = self.abs();
        tmp2 = closure_0;
        num = 5;
        if (arg0 !== closure_0) {
          num = arg0;
        }
        items = [];
        num2 = 0;
        num3 = 2;
        if (0 < num) {
          do {
            tmp3 = outer1_0;
            arr = items.push(outer1_0.randBetween(2, absResult.minus(2), arg1));
            num2 = num2 + 1;
          } while (num2 < num);
        }
        tmp5 = millerRabinTest;
        return millerRabinTest(absResult, items);
      }
    }
    modInv(arg0) {
      self = this;
      zero = outer1_0.zero;
      one = outer1_0.one;
      obj = parseValue(arg0);
      absResult = this.abs();
      obj3 = zero;
      obj4 = obj;
      if (!absResult.isZero()) {
        do {
          divideResult = obj.divide(absResult);
          subtractResult = zero.subtract(divideResult.multiply(one));
          subtractResult1 = obj.subtract(divideResult.multiply(absResult));
          zero = one;
          obj = absResult;
          one = subtractResult;
          absResult = subtractResult1;
          obj3 = zero;
          obj4 = obj;
          isZeroResult = subtractResult1.isZero();
        } while (!isZeroResult);
      }
      if (obj4.isUnit()) {
        num = 0;
        num2 = -1;
        addResult = obj3;
        if (-1 === obj3.compare(0)) {
          addResult = obj3.add(arg0);
        }
        negateResult = addResult;
        if (self.isNegative()) {
          negateResult = addResult.negate();
        }
        return negateResult;
      } else {
        tmp3 = globalThis;
        _Error = Error;
        str = " and ";
        text = `${self.toString()} and `;
        prototype = Error.prototype;
        tmp5 = new.target;
        str2 = " are not co-prime";
        tmp6 = new.target;
        error = new Error(`${self.toString()} and ` + arg0.toString() + " are not co-prime");
        tmp8 = error;
        throw error;
      }
    }
    next() {
      self = this;
      value = this.value;
      if (this.sign) {
        tmp6 = subtractSmall;
        num2 = 1;
        tmp5 = subtractSmall(value, 1, self.sign);
      } else {
        tmp = BigInteger;
        tmp2 = addSmall;
        num = 1;
        prototype = BigInteger.prototype;
        tmp3 = new.target;
        tmp4 = new.target;
        tmp5 = new BigInteger(addSmall(value, 1), self.sign);
      }
      return tmp5;
    }
    prev() {
      value = this.value;
      if (this.sign) {
        tmp4 = BigInteger;
        tmp5 = addSmall;
        num2 = 1;
        prototype = BigInteger.prototype;
        tmp6 = new.target;
        flag = true;
        tmp7 = new.target;
        tmp3 = new BigInteger(addSmall(value, 1), true);
      } else {
        tmp2 = subtractSmall;
        num = 1;
        tmp3 = subtractSmall(value, 1, tmp.sign);
      }
      return tmp3;
    }
    shiftLeft(arg0) {
      self = this;
      obj = parseValue(arg0);
      toJSNumberResult = obj.toJSNumber();
      if (shift_isSmall(toJSNumberResult)) {
        num = 0;
        if (toJSNumberResult < 0) {
          return self.shiftRight(-toJSNumberResult);
        } else if (self.isZero()) {
          return self;
        } else {
          tmp7 = length;
          num2 = 1;
          diff = toJSNumberResult;
          multiplyResult = self;
          obj3 = self;
          tmp9 = toJSNumberResult;
          if (toJSNumberResult >= length) {
            do {
              tmp10 = length;
              multiplyResult = multiplyResult.multiply(length);
              tmp11 = length;
              diff = diff - (length - 1);
              tmp12 = length;
              obj3 = multiplyResult;
              tmp9 = diff;
            } while (diff >= length);
          }
          tmp13 = Object;
          return obj3.multiply(Object[tmp9]);
        }
      } else {
        tmp2 = globalThis;
        _Error = Error;
        _String = String;
        str = " is too large for shifting.";
        prototype = Error.prototype;
        tmp3 = new.target;
        tmp4 = new.target;
        error = new Error(String(toJSNumberResult) + " is too large for shifting.");
        tmp6 = error;
        throw error;
      }
    }
    shiftRight(arg0) {
      self = this;
      obj = parseValue(arg0);
      toJSNumberResult = obj.toJSNumber();
      if (shift_isSmall(toJSNumberResult)) {
        num = 0;
        if (toJSNumberResult < 0) {
          return self.shiftLeft(-toJSNumberResult);
        } else {
          tmp21 = length;
          num2 = 1;
          diff = toJSNumberResult;
          obj4 = self;
          tmp15 = self;
          tmp16 = toJSNumberResult;
          if (toJSNumberResult >= length) {
            tmp7 = obj4;
            while (!obj4.isZero()) {
              if (!obj4.isNegative()) {
                tmp8 = divModAny;
                tmp9 = length;
                tmp10 = divModAny(obj4, length);
                [obj3, obj2] = tmp10;
                if (obj2.isNegative()) {
                  prevResult = obj3.prev();
                } else {
                  prevResult = obj3;
                }
                tmp12 = length;
                diff = diff - (length - 1);
                tmp14 = length;
                obj4 = prevResult;
                tmp15 = prevResult;
                tmp16 = diff;
              } else if (obj4.isUnit()) {
                break;
              }
              return obj4;
            }
          }
          tmp17 = divModAny;
          tmp18 = Object;
          tmp19 = divModAny(tmp15, Object[tmp16]);
          [obj6, obj5] = tmp19;
          if (obj5.isNegative()) {
            prevResult1 = obj6.prev();
          } else {
            prevResult1 = obj6;
          }
          return prevResult1;
        }
      } else {
        tmp2 = globalThis;
        _Error = Error;
        _String = String;
        str = " is too large for shifting.";
        prototype = Error.prototype;
        tmp3 = new.target;
        tmp4 = new.target;
        error = new Error(String(toJSNumberResult) + " is too large for shifting.");
        tmp6 = error;
        throw error;
      }
    }
    not() {
      negateResult = this.negate();
      return negateResult.prev();
    }
    and(arg0) {
      return bitwise(this, arg0, (arg0, arg1) => arg0 & arg1);
    }
    or(arg0) {
      return bitwise(this, arg0, (arg0, arg1) => arg0 | arg1);
    }
    xor(arg0) {
      return bitwise(this, arg0, (arg0, arg1) => arg0 ^ arg1);
    }
    bitLength() {
      self = this;
      self2 = this;
      if (this.compareTo(outer1_0(0)) < 0) {
        negateResult = self.negate();
        tmp = outer1_0;
        num = 1;
        self2 = negateResult.subtract(outer1_0(1));
      }
      if (0 === self2.compareTo(outer1_0(0))) {
        tmp6 = outer1_0;
        addResult = outer1_0(0);
      } else {
        tmp2 = outer1_0;
        tmp3 = integerLogarithm;
        num2 = 2;
        obj2 = outer1_0(integerLogarithm(self2, outer1_0(2)).e);
        tmp4 = outer1_0;
        num3 = 1;
        addResult = obj2.add(outer1_0(1));
      }
      return addResult;
    }
    toArray(arg0) {
      return toBase(this, arg0);
    }
    toString(arg0, arg1) {
      num = arg0;
      self = this;
      if (arg0 === closure_0) {
        num = 10;
      }
      if (10 !== num) {
        tmp4 = toBaseString;
        tmp5 = arg1;
        return toBaseString(self, num, arg1);
      } else {
        value = self.value;
        tmp6 = globalThis;
        _String2 = String;
        diff = value.length - 1;
        StringResult = String(value[diff]);
        diff1 = diff - 1;
        str2 = "0000000";
        num2 = 0;
        sum = StringResult;
        tmp3 = StringResult;
        if (diff1 >= 0) {
          do {
            _String = String;
            StringResult1 = String(value[diff1]);
            slice = "0000000".slice;
            sum = sum + ("0000000".slice(StringResult1.length) + StringResult1);
            diff1 = diff1 - 1;
            tmp3 = sum;
          } while (diff1 >= 0);
        }
        str = "";
        if (self.sign) {
          str = "-";
        }
        return str + tmp3;
      }
    }
    valueOf() {
      return parseInt(this.toString(), 10);
    }
  }
  class SmallInteger {
    constructor(arg0) {
      this.value = arg0;
      this.sign = arg0 < 0;
      this.isSmall = true;
      return;
    }
    add(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      if (value < 0 !== iter.sign) {
        return self.subtract(iter.negate());
      } else {
        value = iter.value;
        tmp4 = value;
        if (iter.isSmall) {
          tmp = isPrecise;
          if (isPrecise(value + value)) {
            tmp12 = SmallInteger;
            prototype2 = SmallInteger.prototype;
            tmp13 = new.target;
            tmp14 = new.target;
            tmp15 = new SmallInteger(value + value);
            tmp16 = tmp15;
            return tmp15;
          } else {
            tmp2 = smallToArray;
            tmp3 = globalThis;
            _Math = Math;
            tmp4 = smallToArray(Math.abs(value));
          }
        }
        tmp5 = BigInteger;
        tmp6 = addSmall;
        tmp7 = globalThis;
        _Math2 = Math;
        prototype = BigInteger.prototype;
        tmp8 = new.target;
        tmp9 = new.target;
        tmp10 = new BigInteger(addSmall(tmp4, Math.abs(value)), value < 0);
        tmp11 = tmp10;
        return tmp10;
      }
    }
    subtract(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      if (value < 0 !== iter.sign) {
        return self.add(iter.negate());
      } else {
        value = iter.value;
        if (iter.isSmall) {
          tmp4 = SmallInteger;
          prototype = SmallInteger.prototype;
          tmp5 = new.target;
          tmp6 = new.target;
          tmp3 = new SmallInteger(value - value);
        } else {
          tmp = subtractSmall;
          tmp2 = globalThis;
          _Math = Math;
          tmp3 = subtractSmall(value, Math.abs(value), value >= 0);
        }
        return tmp3;
      }
    }
    negate() {
      tmp = new SmallInteger(-this.value);
      tmp.sign = !this.sign;
      return tmp;
    }
    abs() {
      tmp = new SmallInteger(Math.abs(this.value));
      return tmp;
    }
    _multiplyBySmall(arg0) {
      self = this;
      if (isPrecise(arg0.value * this.value)) {
        tmp6 = SmallInteger;
        prototype = SmallInteger.prototype;
        tmp7 = new.target;
        tmp8 = new.target;
        tmp5 = new SmallInteger(arg0.value * self.value);
      } else {
        tmp = multiplySmallAndArray;
        tmp2 = globalThis;
        _Math = Math;
        tmp4 = smallToArray;
        _Math2 = Math;
        absolute = Math.abs(arg0.value);
        tmp5 = multiplySmallAndArray(absolute, smallToArray(Math.abs(self.value)), self.sign !== arg0.sign);
      }
      return tmp5;
    }
    multiply(arg0) {
      obj = parseValue(arg0);
      return obj._multiplyBySmall(this);
    }
    square() {
      result = this.value * this.value;
      if (isPrecise(result)) {
        tmp9 = SmallInteger;
        prototype2 = SmallInteger.prototype;
        tmp10 = new.target;
        tmp11 = new.target;
        tmp12 = result;
        tmp8 = new SmallInteger(result);
      } else {
        tmp2 = BigInteger;
        tmp3 = square;
        tmp4 = smallToArray;
        tmp5 = globalThis;
        _Math = Math;
        prototype = BigInteger.prototype;
        tmp6 = new.target;
        flag = false;
        tmp7 = new.target;
        tmp8 = new BigInteger(square(smallToArray(Math.abs(this.value))), false);
      }
      return tmp8;
    }
    compareAbs(arg0) {
      tmp = parseValue(arg0);
      absolute = Math.abs(this.value);
      num = -1;
      num2 = -1;
      if (tmp.isSmall) {
        _Math = Math;
        absolute1 = Math.abs(tmp3);
        num3 = 0;
        if (absolute !== absolute1) {
          if (absolute > absolute1) {
            num = 1;
          }
          num3 = num;
        }
        num2 = num3;
      }
      return num2;
    }
    compare(arg0) {
      if (arg0 === Infinity) {
        num6 = -1;
        return -1;
      } else {
        num7 = -Infinity;
        if (arg0 === -Infinity) {
          num5 = 1;
          return 1;
        } else {
          tmp = parseValue;
          iter = parseValue(arg0);
          self = this;
          value = this.value;
          value = iter.value;
          num8 = 0;
          if (iter.isSmall) {
            num3 = 0;
            if (value != value) {
              num4 = -1;
              if (value > value) {
                num4 = 1;
              }
              num3 = num4;
            }
            num = num3;
          } else if (value < 0 !== iter.sign) {
            num2 = 1;
            if (value < 0) {
              num2 = -1;
            }
            num = num2;
          } else {
            num = -1;
            if (value < 0) {
              num = 1;
            }
          }
          return num;
        }
      }
    }
    isEven() {
      return !(1 & this.value);
    }
    isOdd() {
      return !(1 & ~this.value);
    }
    isPositive() {
      return this.value > 0;
    }
    isNegative() {
      return this.value < 0;
    }
    isUnit() {
      return 1 === Math.abs(this.value);
    }
    isZero() {
      return 0 === this.value;
    }
    next() {
      value = this.value;
      if (value + 1 < 9007199254740992) {
        tmp6 = SmallInteger;
        prototype2 = SmallInteger.prototype;
        tmp7 = new.target;
        tmp8 = new.target;
        tmp5 = new SmallInteger(value + 1);
      } else {
        tmp = BigInteger;
        tmp2 = c1;
        prototype = BigInteger.prototype;
        tmp3 = new.target;
        flag = false;
        tmp4 = new.target;
        tmp5 = new BigInteger(c1, false);
      }
      return tmp5;
    }
    prev() {
      value = this.value;
      if (value - 1 > -9007199254740992) {
        tmp6 = SmallInteger;
        prototype2 = SmallInteger.prototype;
        tmp7 = new.target;
        tmp8 = new.target;
        tmp5 = new SmallInteger(value - 1);
      } else {
        tmp = BigInteger;
        tmp2 = c1;
        prototype = BigInteger.prototype;
        tmp3 = new.target;
        flag = true;
        tmp4 = new.target;
        tmp5 = new BigInteger(c1, true);
      }
      return tmp5;
    }
    toArray(arg0) {
      return toBase(this, arg0);
    }
    toString(arg0, arg1) {
      num = arg0;
      self = this;
      if (arg0 === closure_0) {
        num = 10;
      }
      if (10 != num) {
        tmp3 = toBaseString;
        tmp4 = arg1;
        StringResult = toBaseString(self, num, arg1);
      } else {
        tmp = globalThis;
        _String = String;
        StringResult = String(self.value);
      }
      return StringResult;
    }
    valueOf() {
      return this.value;
    }
  }
  class NativeBigInt {
    constructor(arg0) {
      this.value = arg0;
      return;
    }
    add(arg0) {
      tmp = new NativeBigInt(this.value + parseValue(arg0).value);
      return tmp;
    }
    subtract(arg0) {
      tmp = new NativeBigInt(this.value - parseValue(arg0).value);
      return tmp;
    }
    negate() {
      tmp = new NativeBigInt(-this.value);
      return tmp;
    }
    abs() {
      self = this;
      tmp = NativeBigInt;
      if (this.value >= 0) {
        value = self.value;
      } else {
        value = -self.value;
      }
      tmp = new tmp(value);
      return tmp;
    }
    multiply(arg0) {
      tmp = new NativeBigInt(this.value * parseValue(arg0).value);
      return tmp;
    }
    square(arg0) {
      tmp = new NativeBigInt(this.value * this.value);
      return tmp;
    }
    pow(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      value = iter.value;
      BigIntResult = BigInt(0);
      BigIntResult1 = BigInt(1);
      if (value === BigIntResult) {
        tmp20 = Integer;
        return Integer[1];
      } else if (value === BigIntResult) {
        tmp19 = Integer;
        return Integer[0];
      } else if (value === BigIntResult1) {
        tmp18 = Integer;
        return Integer[1];
      } else {
        _BigInt = BigInt;
        num = -1;
        if (value === BigInt(-1)) {
          tmp17 = Integer;
          return iter.isEven() ? tmp17[1] : tmp17[-1];
        } else if (iter.isNegative()) {
          tmp11 = NativeBigInt;
          prototype = NativeBigInt.prototype;
          tmp12 = new.target;
          tmp13 = new.target;
          tmp14 = BigIntResult;
          tmp15 = new NativeBigInt(BigIntResult);
          tmp16 = tmp15;
          return tmp15;
        } else {
          tmp4 = Integer;
          obj = Integer[1];
          diff = value;
          timesResult = obj;
          if ((value & BigIntResult1) === BigIntResult1) {
            timesResult = obj.times(self);
            diff = value - 1;
          }
          obj2 = self;
          obj3 = timesResult;
          tmp7 = timesResult;
          if (diff !== BigIntResult) {
            do {
              result = diff / tmp3;
              squareResult = obj2.square();
              diff = result;
              timesResult1 = obj3;
              if ((result & BigIntResult1) === BigIntResult1) {
                timesResult1 = obj3.times(squareResult);
                diff = result - 1;
              }
              obj3 = timesResult1;
              obj2 = squareResult;
              tmp7 = timesResult1;
            } while (diff !== BigIntResult);
          }
          return tmp7;
        }
      }
    }
    compareAbs(arg0) {
      value = this.value;
      value = parseValue(arg0).value;
      tmp = value;
      if (value < 0) {
        tmp = -value;
      }
      tmp2 = value;
      if (value < 0) {
        tmp2 = -value;
      }
      num = 0;
      if (tmp !== tmp2) {
        num2 = -1;
        if (tmp > tmp2) {
          num2 = 1;
        }
        num = num2;
      }
      return num;
    }
    compare(arg0) {
      if (arg0 === Infinity) {
        num5 = -1;
        return -1;
      } else {
        num = -Infinity;
        if (arg0 === -Infinity) {
          num4 = 1;
          return 1;
        } else {
          self = this;
          value = this.value;
          tmp = parseValue;
          value = parseValue(arg0).value;
          num2 = 0;
          if (value !== value) {
            num3 = -1;
            if (value > value) {
              num3 = 1;
            }
            num2 = num3;
          }
          return num2;
        }
      }
    }
    isEven() {
      tmp = this.value & BigInt(1);
      return tmp === BigInt(0);
    }
    isOdd() {
      tmp = this.value & BigInt(1);
      return tmp === BigInt(1);
    }
    isUnit() {
      return this.abs().value === BigInt(1);
    }
    isZero() {
      return this.value === BigInt(0);
    }
    next() {
      tmp = new NativeBigInt(this.value + BigInt(1));
      return tmp;
    }
    prev() {
      tmp = new NativeBigInt(this.value - BigInt(1));
      return tmp;
    }
    toArray(arg0) {
      return toBase(this, arg0);
    }
  }
  function isPrecise(powResult) {
    let tmp = -9007199254740992 < powResult;
    if (tmp) {
      tmp = powResult < 9007199254740992;
    }
    return tmp;
  }
  function smallToArray(absolute) {
    if (absolute < 10000000) {
      const items = [absolute];
      let items2 = items;
    } else if (absolute < 100000000000000) {
      const items1 = [absolute % 10000000, ];
      const _Math3 = Math;
      items1[1] = Math.floor(absolute / 10000000);
      items2 = items1;
    } else {
      items2 = [absolute % 10000000, , ];
      const _Math = Math;
      items2[1] = Math.floor(absolute / 10000000) % 10000000;
      const _Math2 = Math;
      items2[2] = Math.floor(absolute / 100000000000000);
    }
    return items2;
  }
  function arrayToSmall(array) {
    trim(array);
    if (array.length < 4) {
      if (compareAbs(array, closure_1) < 0) {
        if (0 === length) {
          return 0;
        } else if (1 === length) {
          return array[0];
        } else if (2 === length) {
          return array[0] + array[1] * 10000000;
        } else {
          return array[0] + (array[1] + array[2] * 10000000) * 10000000;
        }
      }
    }
    return array;
  }
  function trim(arg0) {
    let tmp5;
    const diff = arg0.length - 1;
    let tmp2 = diff;
    let tmp3 = diff;
    if (0 === arg0[diff]) {
      do {
        let diff1 = tmp2 - 1;
        tmp2 = diff1;
        tmp3 = diff1;
        tmp5 = arg0[diff1];
      } while (0 === tmp5);
    }
    arg0.length = tmp3 + 1;
  }
  function createArray(length) {
    const array = new Array(length);
    for (let num = 0; num < length; num = num + 1) {
      array[num] = 0;
    }
    return array;
  }
  function truncate(endImportTime) {
    if (endImportTime > 0) {
      const _Math2 = Math;
      let rounded = Math.floor(endImportTime);
    } else {
      const _Math = Math;
      rounded = Math.ceil(endImportTime);
    }
    return rounded;
  }
  function add(arg0, arg1) {
    let arr = new Array(length);
    let num = 0;
    let num2 = 0;
    let num3 = 0;
    let num4 = 0;
    if (0 < arg1.length) {
      do {
        let sum = arg0[num] + arg1[num] + num2;
        let num5 = 0;
        if (sum >= 10000000) {
          num5 = 1;
        }
        arr[num] = sum - num5 * 10000000;
        num = num + 1;
        num2 = num5;
        num4 = num5;
        num3 = num;
      } while (num < length2);
    }
    let tmp2 = num4;
    let tmp3 = num4;
    if (num3 < arg0.length) {
      do {
        let sum1 = arg0[num3] + tmp2;
        let num6 = 0;
        if (sum1 === 10000000) {
          num6 = 1;
        }
        let tmp5 = +num3;
        num3 = tmp5 + 1;
        arr[tmp5] = sum1 - num6 * 10000000;
        tmp2 = num6;
        tmp3 = num6;
      } while (num3 < length);
    }
    if (tmp3 > 0) {
      arr = arr.push(tmp3);
    }
    return arr;
  }
  function addAny(substr1, substr) {
    if (substr1.length >= substr.length) {
      let tmp2 = add(substr1, substr);
    } else {
      tmp2 = add(substr, substr1);
    }
    return tmp2;
  }
  function addSmall(value, arg1) {
    let sum1 = arg1;
    const array = new Array(length);
    let num = 0;
    let rounded1 = arg1;
    let num2 = 0;
    if (0 < value.length) {
      do {
        let sum = value[num] - 10000000 + sum1;
        let _Math = Math;
        let rounded = Math.floor(sum / 10000000);
        array[num] = sum - rounded * 10000000;
        sum1 = rounded + 1;
        num = num + 1;
        rounded1 = sum1;
        num2 = num;
      } while (num < length);
    }
    if (rounded1 > 0) {
      do {
        let tmp6 = +num2;
        num2 = tmp6 + 1;
        array[tmp6] = rounded1 % 10000000;
        let _Math2 = Math;
        rounded1 = Math.floor(rounded1 / 10000000);
      } while (rounded1 > 0);
    }
    return array;
  }
  function subtract(arg0, arg1) {
    const array = new Array(length);
    let num = 0;
    let num2 = 0;
    let num3 = 0;
    if (0 < arg1.length) {
      do {
        let diff = arg0[num] - num2 - arg1[num];
        let num4 = 0;
        let sum = diff;
        if (diff < 0) {
          sum = diff + 10000000;
          num4 = 1;
        }
        array[num] = sum;
        num = num + 1;
        num2 = num4;
        num3 = num4;
      } while (num < length2);
    }
    let sum1 = length2;
    let sum2 = length2;
    if (arg1.length < arg0.length) {
      const diff1 = arg0[sum1] - num3;
      while (diff1 < 0) {
        array[sum1] = diff1 + 10000000;
        sum1 = sum1 + 1;
        sum2 = sum1;
      }
      sum2 = tmp7 + 1;
      array[+sum1] = diff1;
    }
    if (sum2 < arg0.length) {
      do {
        array[sum2] = arg0[sum2];
        sum2 = sum2 + 1;
      } while (sum2 < length);
    }
    trim(array);
    return array;
  }
  function subtractSmall(value, arg1, sign) {
    const array = new Array(length);
    let tmp2 = -arg1;
    let num = 0;
    if (0 < value.length) {
      do {
        let sum = value[num] + tmp2;
        let _Math = Math;
        let result = sum % 10000000;
        let sum1 = result;
        let rounded = Math.floor(sum / 10000000);
        if (result < 0) {
          sum1 = result + 10000000;
        }
        array[num] = sum1;
        num = num + 1;
        tmp2 = rounded;
      } while (num < length);
    }
    const tmp7 = arrayToSmall(array);
    if ("number" === typeof tmp7) {
      let tmp14 = tmp7;
      if (sign) {
        tmp14 = -tmp7;
      }
      const prototype2 = SmallInteger.prototype;
      let tmp13 = new SmallInteger(tmp14);
    } else {
      const prototype = BigInteger.prototype;
      tmp13 = new BigInteger(tmp7, sign);
    }
    return tmp13;
  }
  function multiplyLong(value, arr2) {
    const tmp = createArray(value.length + arr2.length);
    for (let num = 0; num < length; num = num + 1) {
      for (let num2 = 0; num2 < length2; num2 = num2 + 1) {
        let sum = tmp2 * arr2[num2] + tmp[num + num2];
        let _Math = Math;
        let rounded = Math.floor(sum / 10000000);
        tmp[num + num2] = sum - rounded * 10000000;
        let sum1 = num + num2 + 1;
        tmp[sum1] = tmp[sum1] + rounded;
      }
    }
    trim(tmp);
    return tmp;
  }
  function multiplySmall(arr1, rounded) {
    const array = new Array(length);
    let num = 0;
    let num2 = 0;
    let num3 = 0;
    let num4 = 0;
    if (0 < arr1.length) {
      do {
        let sum = arr1[num] * rounded + num2;
        let _Math = Math;
        rounded = Math.floor(sum / 10000000);
        array[num] = sum - rounded * 10000000;
        num = num + 1;
        num2 = rounded;
        num4 = rounded;
        num3 = num;
      } while (num < length);
    }
    if (num4 > 0) {
      do {
        let tmp4 = +num3;
        num3 = tmp4 + 1;
        array[tmp4] = num4 % 10000000;
        let _Math2 = Math;
        num4 = Math.floor(num4 / 10000000);
      } while (num4 > 0);
    }
    return array;
  }
  function shiftLeft(arg0, rounded) {
    let tmp4;
    const items = [];
    let diff = tmp - 1;
    if (+rounded > 0) {
      do {
        let arr = items.push(0);
        tmp4 = +diff;
        diff = tmp4 - 1;
      } while (tmp4 > 0);
    }
    return items.concat(arg0);
  }
  function multiplyKaratsuba(substr, arr2) {
    const bound = Math.max(substr.length, arr2.length);
    if (bound <= 30) {
      return multiplyLong(substr, arr2);
    } else {
      const _Math = Math;
      const rounded = Math.ceil(bound / 2);
      substr = substr.slice(rounded);
      const substr1 = substr.slice(0, rounded);
      const substr2 = arr2.slice(rounded);
      const substr3 = arr2.slice(0, rounded);
      const tmp9 = multiplyKaratsuba(substr1, substr3);
      const tmp10 = multiplyKaratsuba(substr, substr2);
      const tmp12 = addAny(substr1, substr);
      const tmp16 = addAny(addAny(tmp9, shiftLeft(subtract(subtract(multiplyKaratsuba(addAny(substr1, substr), addAny(substr3, substr2)), tmp9), tmp10), rounded)), shiftLeft(tmp10, 2 * rounded));
      trim(tmp16);
      return tmp16;
    }
  }
  function multiplySmallAndArray(absolute, value, arg2) {
    let tmp = BigInteger;
    if (absolute < 10000000) {
      let tmp4 = multiplySmall(value, absolute);
    } else {
      tmp4 = multiplyLong(value, smallToArray(absolute));
    }
    tmp = new tmp(tmp4, arg2);
    return tmp;
  }
  function square(value) {
    const tmp = createArray(value.length + value.length);
    for (let num = 0; num < length; num = num + 1) {
      let tmp2 = value[num];
      let diff = 0 - tmp2 * tmp2;
      let tmp4 = diff;
      let sum1 = num;
      if (num < length) {
        do {
          let sum = tmp2 * value[sum1] * 2 + tmp[num + sum1] + diff;
          let _Math = Math;
          let rounded = Math.floor(sum / 10000000);
          tmp[num + sum1] = sum - rounded * 10000000;
          sum1 = sum1 + 1;
          diff = rounded;
          tmp4 = rounded;
        } while (sum1 < length);
      }
      tmp[num + length] = tmp4;
    }
    trim(tmp);
    return tmp;
  }
  function divModSmall(arr5, error) {
    const tmp = createArray(arr5.length);
    let diff = length - 1;
    let num = 0;
    let num2 = 0;
    if (diff >= 0) {
      do {
        let sum = num * 10000000 + arr5[diff];
        let tmp4 = truncate;
        let tmp5 = truncate(sum / error);
        num = sum - tmp5 * error;
        tmp[diff] = tmp5 | 0;
        diff = diff - 1;
        num2 = num;
      } while (diff >= 0);
    }
    const items = [tmp, num2 | 0];
    return items;
  }
  function divModAny(value, closure_6) {
    const iter = parseValue(closure_6);
    if (closure_3) {
      let error = NativeBigInt;
      const prototype12 = NativeBigInt.prototype;
      error = new.target;
      error = new.target;
      error = new NativeBigInt(value.value / iter.value);
      const items = [error, ];
      const prototype13 = NativeBigInt.prototype;
      error = new.target;
      error = new.target;
      error = new NativeBigInt(value.value % iter.value);
      items[1] = error;
      return items;
    } else {
      value = value.value;
      value = iter.value;
      if (0 === value) {
        error = globalThis;
        const _Error = Error;
        error = new.target;
        error = new.target;
        error = new Error("Cannot divide by zero");
        throw error;
      } else {
        const isSmall = iter.isSmall;
        if (value.isSmall) {
          if (isSmall) {
            error = SmallInteger;
            error = truncate;
            const prototype9 = SmallInteger.prototype;
            error = new.target;
            error = new.target;
            error = new SmallInteger(truncate(value / value));
            const items1 = [error, ];
            const prototype10 = SmallInteger.prototype;
            error = new.target;
            error = new.target;
            error = new SmallInteger(value % value);
            items1[1] = error;
            let items2 = items1;
          } else {
            error = Integer;
            items2 = [Integer[0], value];
          }
          return items2;
        } else {
          let arr1 = value;
          if (isSmall) {
            if (1 === value) {
              const items3 = [value, ];
              error = Integer;
              items3[1] = Integer[0];
              return items3;
            } else if (-1 == value) {
              const items4 = [value.negate(), ];
              error = Integer;
              items4[1] = Integer[0];
              return items4;
            } else {
              error = globalThis;
              const _Math5 = Math;
              error = Math.abs(value);
              if (error < 10000000) {
                const tmp76 = divModSmall(value, error);
                const tmp77 = arrayToSmall(tmp76[0]);
                let tmp79 = tmp78;
                if (value.sign) {
                  tmp79 = -tmp78;
                }
                if ("number" === typeof tmp77) {
                  let tmp92 = tmp77;
                  if (value.sign !== iter.sign) {
                    tmp92 = -tmp77;
                  }
                  const prototype7 = SmallInteger.prototype;
                  const tmp97 = new SmallInteger(tmp92);
                  const items5 = [tmp97, ];
                  const prototype8 = SmallInteger.prototype;
                  error = new.target;
                  error = tmp79;
                  error = new SmallInteger(tmp79);
                  items5[1] = error;
                  let items6 = items5;
                } else {
                  const prototype5 = BigInteger.prototype;
                  const tmp84 = new BigInteger(tmp77, value.sign !== iter.sign);
                  items6 = [tmp84, ];
                  const prototype6 = SmallInteger.prototype;
                  const tmp90 = new SmallInteger(tmp79);
                  items6[1] = tmp90;
                }
                return items6;
              } else {
                error = smallToArray;
                arr1 = smallToArray(error);
              }
            }
          }
          error = compareAbs;
          const tmp2 = compareAbs(value, arr1);
          let num3 = -1;
          if (-1 === tmp2) {
            const items7 = [Integer[0], value];
            return items7;
          } else if (0 === tmp2) {
            if (value.sign === iter.sign) {
              num3 = 1;
            }
            const items8 = [Integer[num3], Integer[0]];
            return items8;
          } else {
            if (value.length + arr1.length <= 200) {
              const tmp29 = createArray(arr1.length);
              const _Math2 = Math;
              const rounded = Math.ceil(10000000 / (2 * arr1[length3 - 1]));
              const arr5 = multiplySmall(value, rounded);
              const arr6 = multiplySmall(arr1, rounded);
              if (arr5.length <= value.length) {
                arr5.push(0);
              }
              arr6.push(0);
              let diff = length2 - length3;
              if (diff >= 0) {
                do {
                  let num8 = 9999999;
                  if (arr5[diff + length3] !== tmp35) {
                    let _Math3 = Math;
                    num8 = Math.floor((arr5[diff + length3] * 10000000 + arr5[diff + length3 - 1]) / tmp35);
                  }
                  let length4 = arr6.length;
                  let num9 = 0;
                  let num10 = 0;
                  let num11 = 0;
                  let num12 = 0;
                  if (0 < length4) {
                    do {
                      let sum = num9 + num8 * arr6[num11];
                      let _Math4 = Math;
                      let rounded1 = Math.floor(sum / 10000000);
                      let sum1 = num10 + (arr5[diff + num11] - (sum - rounded1 * 10000000));
                      if (sum1 < 0) {
                        arr5[diff + num11] = sum1 + 10000000;
                        let num13 = num3;
                      } else {
                        arr5[diff + num11] = sum1;
                        num13 = 0;
                      }
                      num11 = num11 + 1;
                      num10 = num13;
                      num9 = rounded1;
                      num12 = num13;
                    } while (num11 < length4);
                  }
                  let tmp40 = num8;
                  let tmp41 = num8;
                  if (0 !== num12) {
                    do {
                      let diff1 = tmp40 - 1;
                      let num14 = 0;
                      let num15 = 0;
                      let num16 = 0;
                      if (0 < length4) {
                        do {
                          let sum2 = num14 + (arr5[diff + num15] - 10000000 + arr6[num15]);
                          if (sum2 < 0) {
                            arr5[diff + num15] = sum2 + 10000000;
                            let num17 = 0;
                          } else {
                            arr5[diff + num15] = sum2;
                            num17 = 1;
                          }
                          num15 = num15 + 1;
                          num14 = num17;
                          num16 = num17;
                        } while (num15 < length4);
                      }
                      num12 = num12 + num16;
                      tmp40 = diff1;
                      tmp41 = diff1;
                    } while (0 !== num12);
                  }
                  tmp29[diff] = tmp41;
                  diff = diff - 1;
                } while (diff >= 0);
              }
              const items9 = [arrayToSmall(tmp29), arrayToSmall(divModSmall(arr5, rounded)[0])];
              let items12 = items9;
            } else {
              let length = value.length;
              const items10 = [];
              let items11 = [];
              error = globalThis;
              let tmp25 = items11;
              while (length) {
                length = length - 1;
                arr1 = items11.unshift(value[length]);
                let tmp5 = trim;
                let tmp6 = trim(items11);
                let tmp7 = compareAbs;
                let tmp8 = items11;
                if (compareAbs(items11, arr1) < 0) {
                  let arr2 = items10.push(0);
                  let tmp15 = tmp21;
                  let result = tmp22;
                  let sum3 = tmp23;
                  let tmp13 = tmp24;
                  let tmp18 = items11;
                } else {
                  let length6 = items11.length;
                  error = items11[length6 - 1] * 10000000 + items11[length6 - 2];
                  sum3 = arr1[length5 - 1] * 10000000 + arr1[length5 - 2];
                  result = error;
                  if (length6 > length5) {
                    result = (error + 1) * 10000000;
                  }
                  let _Math = Math;
                  let rounded2 = Math.ceil(result / sum3);
                  let tmp11 = compareAbs;
                  let tmp12 = multiplySmall;
                  tmp13 = multiplySmall(arr1, rounded2);
                  let tmp14 = rounded2;
                  tmp15 = rounded2;
                  while (compareAbs(tmp13, items11) > 0) {
                    rounded2 = rounded2 - 1;
                    tmp15 = rounded2;
                    if (!rounded2) {
                      break;
                    }
                  }
                  let arr3 = items10.push(tmp15);
                  let tmp17 = subtract;
                  tmp18 = subtract(items11, tmp13);
                }
                tmp21 = tmp15;
                tmp22 = result;
                tmp23 = sum3;
                tmp24 = tmp13;
                items11 = tmp18;
                tmp25 = tmp18;
              }
              const reversed = items10.reverse();
              items12 = [arrayToSmall(items10), arrayToSmall(tmp25)];
            }
            const first = items12[0];
            const sign = value.sign;
            if ("number" === typeof first) {
              let tmp55 = first;
              if (tmp47) {
                tmp55 = -first;
              }
              const prototype2 = SmallInteger.prototype;
              let tmp54 = new SmallInteger(tmp55);
            } else {
              const prototype = BigInteger.prototype;
              tmp54 = new BigInteger(first, tmp47);
            }
            if ("number" === typeof items12[1]) {
              let tmp66 = tmp48;
              if (sign) {
                tmp66 = -tmp48;
              }
              const prototype4 = SmallInteger.prototype;
              let tmp65 = new SmallInteger(tmp66);
            } else {
              const prototype3 = BigInteger.prototype;
              tmp65 = new BigInteger(tmp48, sign);
            }
            const items13 = [tmp54, tmp65];
            return items13;
          }
        }
      }
    }
  }
  function compareAbs(value, arr1) {
    if (value.length !== arr1.length) {
      let num4 = -1;
      if (value.length > arr1.length) {
        num4 = 1;
      }
      return num4;
    } else {
      let diff = value.length - 1;
      if (diff >= 0) {
        while (value[diff] === arr1[diff]) {
          diff = diff - 1;
        }
        let num3 = -1;
        if (value[diff] > arr1[diff]) {
          num3 = 1;
        }
        return num3;
      }
      return 0;
    }
  }
  function isBasicPrime(abs) {
    const absResult = abs.abs();
    let tmp = !absResult.isUnit();
    if (tmp) {
      let equalsResult = absResult.equals(2);
      if (!equalsResult) {
        equalsResult = absResult.equals(3);
      }
      if (!equalsResult) {
        equalsResult = absResult.equals(5);
      }
      let tmp4 = !tmp3;
      if (!equalsResult) {
        let isEvenResult = absResult.isEven();
        if (!isEvenResult) {
          isEvenResult = absResult.isDivisibleBy(3);
        }
        if (!isEvenResult) {
          isEvenResult = absResult.isDivisibleBy(5);
        }
        let tmp6 = !isEvenResult;
        if (tmp6) {
          const tmp7 = !absResult.lesser(49);
          tmp6 = !tmp7;
          const tmp8 = !tmp7;
        }
        tmp4 = tmp6;
      }
      tmp = tmp4;
    }
    return tmp;
  }
  function millerRabinTest(absResult, items) {
    let isEvenResult;
    const prevResult = absResult.prev();
    let obj2 = prevResult;
    let num = 0;
    let tmp = prevResult;
    let num2 = 0;
    if (prevResult.isEven()) {
      do {
        let divideResult = obj2.divide(2);
        num = num + 1;
        obj2 = divideResult;
        tmp = divideResult;
        num2 = num;
        isEvenResult = divideResult.isEven();
      } while (isEvenResult);
    }
    let num3 = 0;
    if (0 < items.length) {
      while (true) {
        let tmp4 = tmp3;
        if (!absResult.lesser(items[num3])) {
          let tmp5 = outer1_0;
          let obj4 = outer1_0(items[num3]);
          let modPowResult = obj4.modPow(tmp, absResult);
          tmp4 = tmp3;
          let tmp6 = modPowResult;
          if (!modPowResult.isUnit()) {
            tmp4 = tmp3;
            let tmp7 = modPowResult;
            if (!modPowResult.equals(prevResult)) {
              let diff = num2 - 1;
              if (0 === diff) {
                break;
              } else {
                let squareResult = modPowResult.square();
                let modResult = squareResult.mod(absResult);
                while (!modResult.isUnit()) {
                  tmp4 = diff;
                  let tmp9 = modResult;
                  if (!modResult.equals(prevResult)) {
                    diff = diff - 1;
                    modPowResult = modResult;
                    if (0 != diff) {
                      continue;
                    } else {
                      break label0;
                    }
                    let flag = false;
                    return false;
                  }
                  continue;
                }
                let flag2 = false;
                return false;
              }
            }
          }
        }
        num3 = num3 + 1;
        tmp3 = tmp4;
      }
    }
    return true;
  }
  function shift_isSmall(toJSNumberResult) {
    return Math.abs(toJSNumberResult) <= 10000000;
  }
  function bitwise(isNegative, arg1, arg2) {
    const obj = parseValue(arg1);
    const isNegativeResult = isNegative.isNegative();
    const isNegativeResult1 = obj.isNegative();
    let notResult = isNegative;
    if (isNegativeResult) {
      notResult = isNegative.not();
    }
    let notResult1 = obj;
    if (isNegativeResult1) {
      notResult1 = obj.not();
    }
    const items = [];
    let tmp3 = notResult;
    let tmp4 = notResult1;
    if (!notResult.isZero()) {
      while (true) {
        let tmp5 = divModAny;
        let tmp6 = closure_6;
        let tmp7 = divModAny(tmp3, closure_6);
        let obj4 = tmp7[1];
        let toJSNumberResult = obj4.toJSNumber();
        let diff = toJSNumberResult;
        if (isNegativeResult) {
          let tmp10 = closure_6;
          diff = closure_6 - 1 - toJSNumberResult;
        }
        let tmp11 = divModAny;
        let tmp12 = closure_6;
        let tmp13 = divModAny(tmp4, closure_6);
        let obj5 = tmp13[1];
        let toJSNumberResult1 = obj5.toJSNumber();
        let diff1 = toJSNumberResult1;
        if (isNegativeResult1) {
          let tmp16 = closure_6;
          diff1 = closure_6 - 1 - toJSNumberResult1;
        }
        let first = tmp7[0];
        let first1 = tmp13[0];
        let arr = items.push(arg2(diff, diff1));
        tmp3 = first;
        tmp4 = first1;
        if (!first.isZero()) {
          continue;
        } else {
          tmp3 = first;
          tmp4 = first1;
          if (first1.isZero()) {
            break;
          }
        }
        continue;
      }
    } else {
      tmp3 = notResult;
      tmp4 = notResult1;
    }
    let num = 0;
    if (isNegativeResult) {
      num = 1;
    }
    let num2 = 0;
    if (isNegativeResult1) {
      num2 = 1;
    }
    if (0 !== arg2(num, num2)) {
      let tmp19 = outer1_0(-1);
    } else {
      tmp19 = outer1_0(0);
    }
    let diff2 = items.length - 1;
    let addResult = tmp19;
    let tmp22 = tmp19;
    if (diff2 >= 0) {
      do {
        let tmp23 = closure_6;
        let multiplyResult = addResult.multiply(closure_6);
        let tmp24 = outer1_0;
        addResult = multiplyResult.add(outer1_0(items[diff2]));
        diff2 = diff2 - 1;
        tmp22 = addResult;
      } while (diff2 >= 0);
    }
    return tmp22;
  }
  function roughLOB(value) {
    value = value.value;
    if ("number" === typeof value) {
      let tmp2 = value | c7;
    } else if ("bigint" === tmp) {
      const _BigInt = BigInt;
      tmp2 = value | BigInt(c7);
    } else {
      tmp2 = value[0] + value[1] * 10000000 | 1073758208;
    }
    return tmp2 & -tmp2;
  }
  function integerLogarithm(self2, compareTo) {
    let e;
    let p;
    if (compareTo.compareTo(self2) <= 0) {
      ({ p, e } = integerLogarithm(self2, compareTo.square(compareTo)));
      const multiplyResult = p.multiply(compareTo);
      if (multiplyResult.compareTo(self2) <= 0) {
        let obj = { p: multiplyResult, e: 2 * e + 1 };
      } else {
        obj = { p, e: 2 * e };
      }
      return obj;
    } else {
      obj = { p: outer1_0(1), e: 0 };
      return obj;
    }
  }
  function max(arg0, arg1) {
    const obj = parseValue(arg0);
    let tmp = parseValue(arg1);
    if (obj.greater(tmp)) {
      tmp = obj;
    }
    return tmp;
  }
  function min(arg0, arg1) {
    const obj = parseValue(arg0);
    let tmp = parseValue(arg1);
    if (obj.lesser(tmp)) {
      tmp = obj;
    }
    return tmp;
  }
  function gcd(absResult, absResult1) {
    let isEvenResult;
    let obj18;
    let subtractResult;
    absResult = parseValue(absResult).abs();
    const obj = parseValue(absResult);
    absResult1 = parseValue(absResult1).abs();
    if (absResult.equals(absResult1)) {
      return absResult;
    } else if (absResult.isZero()) {
      return absResult1;
    } else if (absResult1.isZero()) {
      return absResult;
    } else {
      let obj5 = absResult;
      let tmp3 = absResult1;
      let obj6 = tmp2;
      if (absResult.isEven()) {
        let obj7 = absResult;
        let obj8 = absResult1;
        let obj9 = tmp2;
        obj5 = absResult;
        tmp3 = absResult1;
        obj6 = tmp2;
        if (absResult1.isEven()) {
          const tmp7 = min(roughLOB(obj7), roughLOB(obj8));
          const divideResult = obj7.divide(tmp7);
          const divideResult1 = obj8.divide(tmp7);
          const multiplyResult = obj9.multiply(tmp7);
          obj5 = divideResult;
          tmp3 = divideResult1;
          obj6 = multiplyResult;
          while (divideResult.isEven()) {
            obj7 = divideResult;
            obj8 = divideResult1;
            obj9 = multiplyResult;
            obj5 = divideResult;
            tmp3 = divideResult1;
            obj6 = multiplyResult;
            if (!divideResult1.isEven()) {
              break;
            }
          }
          const tmp6 = roughLOB(obj7);
        }
      }
      let obj12 = obj5;
      let obj13 = obj5;
      let obj14 = tmp3;
      if (obj5.isEven()) {
        do {
          let tmp9 = roughLOB;
          let divideResult2 = obj12.divide(roughLOB(obj12));
          obj12 = divideResult2;
          obj13 = divideResult2;
          obj14 = tmp3;
          isEvenResult = divideResult2.isEven();
        } while (isEvenResult);
      }
      do {
        let obj16 = obj14;
        let tmp11 = obj14;
        if (obj14.isEven()) {
          do {
            let tmp12 = roughLOB;
            let divideResult3 = obj16.divide(roughLOB(obj16));
            obj16 = divideResult3;
            tmp11 = divideResult3;
            isEvenResult1 = divideResult3.isEven();
          } while (isEvenResult1);
        }
        obj18 = obj13;
        let obj19 = tmp11;
        if (obj13.greater(tmp11)) {
          obj18 = tmp11;
          obj19 = obj13;
        }
        subtractResult = obj19.subtract(obj18);
        obj13 = obj18;
        obj14 = subtractResult;
      } while (!subtractResult.isZero());
      let multiplyResult1 = obj18;
      if (!obj6.isUnit()) {
        multiplyResult1 = obj18.multiply(obj6);
      }
      return multiplyResult1;
    }
    const obj3 = parseValue(absResult1);
  }
  function parseBaseFromArray(items, constructor, arg2) {
    const first = Integer[0];
    let timesResult = Integer[1];
    let diff = items.length - 1;
    let addResult = first;
    let obj3 = first;
    if (diff >= 0) {
      do {
        let obj4 = items[diff];
        addResult = addResult.add(obj4.times(timesResult));
        timesResult = timesResult.times(constructor);
        diff = diff - 1;
        obj3 = addResult;
      } while (diff >= 0);
    }
    let negateResult = obj3;
    if (arg2) {
      negateResult = obj3.negate();
    }
    return negateResult;
  }
  function toBase(addResult, arg1) {
    let quotient;
    let remainder;
    let obj = outer1_0(arg1);
    if (obj.isZero()) {
      if (addResult.isZero()) {
        obj = { value: [0], isNegative: false };
        return obj;
      } else {
        const _Error = Error;
        const error = new Error("Cannot convert nonzero numbers to base 0.");
        throw error;
      }
    } else if (obj.equals(-1)) {
      if (addResult.isZero()) {
        obj = { value: [0], isNegative: false };
        return obj;
      } else if (addResult.isNegative()) {
        const obj1 = {};
        const concat2 = [].concat;
        const _Array6 = Array;
        const _Array7 = Array;
        const _Array8 = Array;
        obj1.value = concat2.apply([], Array.apply(null, Array(-addResult.toJSNumber())).map(Array.prototype.valueOf, [1, 0]));
        obj1.isNegative = false;
        return obj1;
      } else {
        const _Array3 = Array;
        const _Array4 = Array;
        const _Array5 = Array;
        const mapped = Array.apply(null, Array(addResult.toJSNumber() - 1)).map(Array.prototype.valueOf, [0, 1]);
        mapped.unshift([1]);
        let obj2 = {};
        const concat = [].concat;
        obj2.value = concat.apply([], mapped);
        obj2.isNegative = false;
        return obj2;
      }
    } else {
      let absResult = addResult;
      let flag2 = false;
      if (tmp) {
        absResult = addResult.abs();
        flag2 = true;
      }
      if (obj.isUnit()) {
        let obj3 = {};
        if (absResult.isZero()) {
          obj3.value = [0];
          obj3.isNegative = false;
          let tmp8 = obj3;
        } else {
          const _Array = Array;
          const _Array2 = Array;
          const _Number = Number;
          obj3.value = Array.apply(null, Array(absResult.toJSNumber())).map(Number.prototype.valueOf, 1);
          obj3.isNegative = flag2;
          tmp8 = obj3;
          const applyResult2 = Array.apply(null, Array(absResult.toJSNumber()));
        }
        return tmp8;
      } else {
        const items = [];
        obj2 = absResult;
        if (absResult.isNegative()) {
          while (true) {
            let divmodResult = obj2.divmod(obj);
            ({ quotient, remainder } = divmodResult);
            let nextResult = quotient;
            let absResult1 = remainder;
            if (remainder.isNegative()) {
              let minusResult = obj.minus(remainder);
              absResult1 = minusResult.abs();
              nextResult = quotient.next();
            }
            let arr = items.push(absResult1.toJSNumber());
            let tmp4 = nextResult;
            obj2 = nextResult;
            if (nextResult.isNegative()) {
              continue;
            } else {
              let num3 = 0;
              obj2 = nextResult;
              obj3 = nextResult;
              if (nextResult.compareAbs(obj) < 0) {
                break;
              }
            }
            continue;
          }
        } else {
          obj2 = absResult;
          obj3 = absResult;
        }
        items.push(obj3.toJSNumber());
        const obj4 = { value: items.reverse(), isNegative: flag2 };
        return obj4;
      }
      tmp = addResult.isNegative() && obj.isPositive();
    }
  }
  function toBaseString(self, arg1, arg2) {
    let closure_0 = arg2;
    const iter = toBase(self, arg1);
    let str = "";
    if (iter.isNegative) {
      str = "-";
    }
    const value = iter.value;
    const mapped = value.map((arg0) => {
      let arr = closure_0;
      if (!closure_0) {
        arr = outer1_2;
      }
      if (arg0 < arr.length) {
        let text = arr[arg0];
      } else {
        text = `${"<" + arg0}>`;
      }
      return text;
    });
    return str + mapped.join("");
  }
  function parseStringValue(arr) {
    if (isPrecise(+arr)) {
      if (+arr === truncate(+arr)) {
        if (closure_3) {
          const _BigInt = BigInt;
          const prototype9 = NativeBigInt.prototype;
          let tmp61 = new NativeBigInt(BigInt(tmp49));
        } else {
          const prototype8 = SmallInteger.prototype;
          tmp61 = new SmallInteger(tmp49);
        }
        return tmp61;
      } else {
        const _Error5 = Error;
        const error = new Error("Invalid integer: " + arr);
        throw error;
      }
    } else {
      let str2 = arr;
      if ("-" === arr[0]) {
        str2 = arr.slice(1);
      }
      const parts = str2.split(/e/i);
      if (parts.length > 2) {
        const _Error4 = Error;
        const error1 = new Error("Invalid integer: " + parts.join("e"));
        throw error1;
      } else {
        if (2 === parts.length) {
          let substr = arr4;
          if ("+" === parts[1][0]) {
            substr = arr4.slice(1);
          }
          if (+substr === truncate(+substr)) {
            if (isPrecise(tmp3)) {
              const first = parts[0];
              const index = first.indexOf(".");
              let diff = tmp3;
              let sum = first;
              if (index >= 0) {
                diff = tmp3 - (first.length - index - 1);
                const substr1 = first.slice(0, index);
                sum = substr1 + first.slice(index + 1);
              }
              if (diff < 0) {
                const _Error2 = Error;
                const error2 = new Error("Cannot include negative exponent part for integers");
                throw error2;
              } else {
                const _Array = Array;
                const array = new Array(diff + 1);
                str2 = sum + array.join("0");
              }
            }
          }
          const _Error3 = Error;
          const error3 = new Error("Invalid integer: " + tmp3 + " is not a valid exponent.");
          throw error3;
        }
        if (obj.test(str2)) {
          if (closure_3) {
            let tmp27 = NativeBigInt;
            let text = str2;
            if (tmp) {
              text = `-${str2}`;
            }
            const prototype3 = tmp27.prototype;
            tmp27 = new tmp27(BigInt(text));
            return tmp27;
          } else {
            const items = [];
            let length = str2.length;
            let num5 = length - 7;
            if (length > 0) {
              do {
                arr = items.push(+str2.slice(num5, length));
                num5 = num5 - 7;
                let tmp17 = length;
                if (num5 < 0) {
                  num5 = 0;
                }
                length = length - 7;
              } while (length > 0);
            }
            trim(items);
            const prototype2 = BigInteger.prototype;
            const tmp25 = new BigInteger(items, tmp);
            return tmp25;
          }
        } else {
          const _Error = Error;
          const error4 = new Error("Invalid integer: " + str2);
          throw error4;
        }
        obj = /^([0-9][0-9]*)$/;
      }
    }
  }
  function parseValue(result) {
    if ("number" === typeof result) {
      if (closure_3) {
        const _BigInt = BigInt;
        const prototype4 = NativeBigInt.prototype;
        let tmp12 = new NativeBigInt(BigInt(result));
      } else if (!isPrecise(result)) {
        tmp12 = parseStringValue(result.toString());
      }
      if (result !== truncate(result)) {
        const _Error = Error;
        const error = new Error(result + " is not an integer.");
        throw error;
      } else {
        const prototype2 = SmallInteger.prototype;
        tmp12 = new SmallInteger(result);
      }
    } else {
      if ("string" === tmp) {
        let tmp2 = parseStringValue(result);
      } else {
        tmp2 = result;
        if ("bigint" === tmp) {
          const prototype = NativeBigInt.prototype;
          tmp2 = new NativeBigInt(result);
        }
      }
      return tmp2;
    }
  }
  let closure_1 = smallToArray(9007199254740992);
  let c2 = "0123456789abcdefghijklmnopqrstuvwxyz";
  let closure_3 = "function" === typeof BigInt;
  BigInteger.prototype = Object.create(Integer.prototype);
  SmallInteger.prototype = Object.create(Integer.prototype);
  NativeBigInt.prototype = Object.create(Integer.prototype);
  BigInteger.prototype.plus = BigInteger.prototype.add;
  SmallInteger.prototype.plus = SmallInteger.prototype.add;
  NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
  BigInteger.prototype.minus = BigInteger.prototype.subtract;
  SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
  NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;
  BigInteger.prototype.times = BigInteger.prototype.multiply;
  SmallInteger.prototype.times = SmallInteger.prototype.multiply;
  NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
  const divmod = BigInteger.prototype.divmod;
  SmallInteger.prototype.divmod = divmod;
  NativeBigInt.prototype.divmod = divmod;
  const fn = function(arg0) {
    return new NativeBigInt(this.value / parseValue(arg0).value);
  };
  NativeBigInt.prototype.divide = fn;
  NativeBigInt.prototype.over = fn;
  const divide = BigInteger.prototype.divide;
  BigInteger.prototype.over = divide;
  SmallInteger.prototype.divide = divide;
  SmallInteger.prototype.over = divide;
  const fn2 = function(arg0) {
    return new NativeBigInt(this.value % parseValue(arg0).value);
  };
  NativeBigInt.prototype.remainder = fn2;
  NativeBigInt.prototype.mod = fn2;
  const mod = BigInteger.prototype.mod;
  BigInteger.prototype.remainder = mod;
  SmallInteger.prototype.mod = mod;
  SmallInteger.prototype.remainder = mod;
  SmallInteger.prototype.pow = BigInteger.prototype.pow;
  const modPow = BigInteger.prototype.modPow;
  SmallInteger.prototype.modPow = modPow;
  NativeBigInt.prototype.modPow = modPow;
  BigInteger.prototype.compareTo = BigInteger.prototype.compare;
  SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
  NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;
  const equals = BigInteger.prototype.equals;
  BigInteger.prototype.eq = equals;
  SmallInteger.prototype.equals = equals;
  SmallInteger.prototype.eq = equals;
  NativeBigInt.prototype.equals = equals;
  NativeBigInt.prototype.eq = equals;
  const notEquals = BigInteger.prototype.notEquals;
  BigInteger.prototype.neq = notEquals;
  SmallInteger.prototype.notEquals = notEquals;
  SmallInteger.prototype.neq = notEquals;
  NativeBigInt.prototype.notEquals = notEquals;
  NativeBigInt.prototype.neq = notEquals;
  const greater = BigInteger.prototype.greater;
  BigInteger.prototype.gt = greater;
  SmallInteger.prototype.greater = greater;
  SmallInteger.prototype.gt = greater;
  NativeBigInt.prototype.greater = greater;
  NativeBigInt.prototype.gt = greater;
  const lesser = BigInteger.prototype.lesser;
  BigInteger.prototype.lt = lesser;
  SmallInteger.prototype.lesser = lesser;
  SmallInteger.prototype.lt = lesser;
  NativeBigInt.prototype.lesser = lesser;
  NativeBigInt.prototype.lt = lesser;
  const greaterOrEquals = BigInteger.prototype.greaterOrEquals;
  BigInteger.prototype.geq = greaterOrEquals;
  SmallInteger.prototype.greaterOrEquals = greaterOrEquals;
  SmallInteger.prototype.geq = greaterOrEquals;
  NativeBigInt.prototype.greaterOrEquals = greaterOrEquals;
  NativeBigInt.prototype.geq = greaterOrEquals;
  const lesserOrEquals = BigInteger.prototype.lesserOrEquals;
  BigInteger.prototype.leq = lesserOrEquals;
  SmallInteger.prototype.lesserOrEquals = lesserOrEquals;
  SmallInteger.prototype.leq = lesserOrEquals;
  NativeBigInt.prototype.lesserOrEquals = lesserOrEquals;
  NativeBigInt.prototype.leq = lesserOrEquals;
  NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;
  NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;
  const isDivisibleBy = BigInteger.prototype.isDivisibleBy;
  SmallInteger.prototype.isDivisibleBy = isDivisibleBy;
  NativeBigInt.prototype.isDivisibleBy = isDivisibleBy;
  const isPrime = BigInteger.prototype.isPrime;
  SmallInteger.prototype.isPrime = isPrime;
  NativeBigInt.prototype.isPrime = isPrime;
  const isProbablePrime = BigInteger.prototype.isProbablePrime;
  SmallInteger.prototype.isProbablePrime = isProbablePrime;
  NativeBigInt.prototype.isProbablePrime = isProbablePrime;
  const modInv = BigInteger.prototype.modInv;
  SmallInteger.prototype.modInv = modInv;
  NativeBigInt.prototype.modInv = modInv;
  let items = [1];
  if (2 * items[items.length - 1] <= 10000000) {
    class Integer {
      constructor(arg0, arg1, arg2, arg3) {
        if (undefined === arg0) {
          tmp8 = Integer;
          num2 = 0;
          first = Integer[0];
        } else if (undefined === arg1) {
          tmp = parseValue;
          first = parseValue(arg0);
        } else {
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          tmp4 = arg3;
          tmp5 = arg0;
          tmp6 = arg1;
          tmp7 = arg2;
          first = parseBase(arg0, arg1, arg2, arg3);
        }
        return first;
      }
    }
  }
  let length = items.length;
  let closure_6 = items[length - 1];
  shiftLeft = BigInteger.prototype.shiftLeft;
  SmallInteger.prototype.shiftLeft = shiftLeft;
  NativeBigInt.prototype.shiftLeft = shiftLeft;
  const shiftRight = BigInteger.prototype.shiftRight;
  SmallInteger.prototype.shiftRight = shiftRight;
  NativeBigInt.prototype.shiftRight = shiftRight;
  const not = BigInteger.prototype.not;
  SmallInteger.prototype.not = not;
  NativeBigInt.prototype.not = not;
  const and = BigInteger.prototype.and;
  SmallInteger.prototype.and = and;
  NativeBigInt.prototype.and = and;
  const or = BigInteger.prototype.or;
  SmallInteger.prototype.or = or;
  NativeBigInt.prototype.or = or;
  const xor = BigInteger.prototype.xor;
  SmallInteger.prototype.xor = xor;
  NativeBigInt.prototype.xor = xor;
  let c7 = 1073741824;
  const bitLength = BigInteger.prototype.bitLength;
  SmallInteger.prototype.bitLength = bitLength;
  NativeBigInt.prototype.bitLength = bitLength;
  function parseBase(arg0, arg1, arg2, arg3) {
    let length2;
    let tmp10;
    let tmp2;
    let str = arg2;
    if (!arg2) {
      str = c2;
    }
    const str2 = String(arg0);
    let formatted = str2;
    let formatted1 = str;
    if (!arg3) {
      formatted = str2.toLowerCase();
      formatted1 = str.toLowerCase();
    }
    const absolute = Math.abs(arg1);
    const obj = {};
    let num = 0;
    if (0 < formatted1.length) {
      do {
        obj[formatted1[num]] = num;
        num = num + 1;
        length2 = formatted1.length;
      } while (num < length2);
    }
    let num2 = 0;
    if (0 < formatted.length) {
      while (true) {
        tmp2 = formatted[num2];
        if ("-" !== tmp2) {
          if (tmp2 in obj) {
            if (obj[tmp2] >= absolute) {
              if ("1" !== tmp2) {
                break;
              } else if (1 !== absolute) {
                break;
              }
            }
          }
        }
        num2 = num2 + 1;
      }
      const _Error = Error;
      const error = new Error(tmp2 + " is not a valid digit in base " + arg1 + ".");
      throw error;
    }
    const items = [];
    let num3 = 0;
    if ("-" === formatted[0]) {
      num3 = 1;
    }
    if (num3 < formatted.length) {
      while (true) {
        tmp10 = formatted[num3];
        if (tmp10 in obj) {
          let tmp20 = parseValue;
          let arr = items.push(parseValue(obj[tmp10]));
          let sum = num3;
          let tmp15 = tmp9;
        } else {
          let tmp11 = num3;
          if ("<" !== tmp10) {
            break;
          } else {
            sum = tmp11 + 1;
            while (">" !== formatted[sum]) {
              tmp11 = sum;
              if (sum >= formatted.length) {
                break;
              }
            }
            let tmp13 = parseValue;
            arr = items.push(parseValue(formatted.slice(num3 + 1, sum)));
            tmp15 = num3;
          }
        }
        num3 = sum + 1;
        tmp9 = tmp15;
      }
      const _Error2 = Error;
      const error1 = new Error(tmp10 + " is not a valid character");
      throw error1;
    }
    return parseBaseFromArray(items, parseValue(arg1), "-" === formatted[0]);
  }
  NativeBigInt.prototype.toString = SmallInteger.prototype.toString;
  const fn3 = function() {
    return this.toString();
  };
  SmallInteger.prototype.toJSON = fn3;
  BigInteger.prototype.toJSON = fn3;
  NativeBigInt.prototype.toJSON = fn3;
  BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
  SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
  const fn4 = function() {
    return parseInt(this.toString(), 10);
  };
  NativeBigInt.prototype.toJSNumber = fn4;
  NativeBigInt.prototype.valueOf = fn4;
  let num = 0;
  while (true) {
    class Integer {
      constructor(arg0, arg1, arg2, arg3) {
        if (undefined === arg0) {
          tmp8 = Integer;
          num2 = 0;
          first = Integer[0];
        } else if (undefined === arg1) {
          tmp = parseValue;
          first = parseValue(arg0);
        } else {
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          tmp4 = arg3;
          tmp5 = arg0;
          tmp6 = arg1;
          tmp7 = arg2;
          first = parseBase(arg0, arg1, arg2, arg3);
        }
        return first;
      }
    }
    let tmp = num;
    class BigInteger {
      constructor(arg0, arg1) {
        this.value = arg0;
        this.sign = arg1;
        this.isSmall = false;
        return;
      }
      add(arg0) {
        self = this;
        iter = parseValue(arg0);
        if (this.sign !== iter.sign) {
          return self.subtract(iter.negate());
        } else {
          value = self.value;
          value = iter.value;
          tmp = BigInteger;
          if (iter.isSmall) {
            tmp6 = addSmall;
            tmp7 = globalThis;
            _Math = Math;
            prototype2 = tmp.prototype;
            tmp8 = new.target;
            tmp9 = new.target;
            tmp = new tmp(addSmall(value, Math.abs(value)), self.sign);
          } else {
            tmp2 = addAny;
            prototype = tmp.prototype;
            tmp3 = new.target;
            tmp4 = new.target;
            tmp = new tmp(addAny(value, value), self.sign);
          }
          return tmp;
        }
      }
      subtract(arg0) {
        self = this;
        iter = parseValue(arg0);
        if (this.sign !== iter.sign) {
          return self.add(iter.negate());
        } else {
          value = self.value;
          value = iter.value;
          if (iter.isSmall) {
            tmp19 = subtractSmall;
            tmp20 = globalThis;
            _Math = Math;
            tmp13 = subtractSmall(value, Math.abs(value), self.sign);
          } else {
            sign = self.sign;
            tmp = compareAbs;
            num = 0;
            if (compareAbs(value, value) >= 0) {
              tmp5 = subtract;
              tmp3 = subtract(value, value);
              tmp4 = sign;
            } else {
              tmp2 = subtract;
              tmp3 = subtract(value, value);
              tmp4 = !sign;
            }
            tmp6 = arrayToSmall;
            tmp7 = arrayToSmall(tmp3);
            str = "number";
            if ("number" === typeof tmp7) {
              tmp14 = tmp7;
              if (tmp4) {
                tmp14 = -tmp7;
              }
              tmp15 = SmallInteger;
              prototype2 = SmallInteger.prototype;
              tmp16 = new.target;
              tmp17 = new.target;
              tmp18 = tmp14;
              tmp13 = new SmallInteger(tmp14);
            } else {
              tmp8 = BigInteger;
              prototype = BigInteger.prototype;
              tmp9 = new.target;
              tmp10 = new.target;
              tmp11 = tmp7;
              tmp12 = tmp4;
              tmp13 = new BigInteger(tmp7, tmp4);
            }
          }
          return tmp13;
        }
      }
      negate() {
        tmp = new BigInteger(this.value, !this.sign);
        return tmp;
      }
      abs() {
        tmp = new BigInteger(this.value, false);
        return tmp;
      }
      multiply(arg0) {
        self = this;
        iter = parseValue(arg0);
        value = this.value;
        value = iter.value;
        tmp = this.sign !== iter.sign;
        arr2 = value;
        if (iter.isSmall) {
          num = 0;
          if (0 === value) {
            tmp20 = Integer;
            return Integer[0];
          } else {
            num2 = 1;
            if (1 === value) {
              return self;
            } else {
              num3 = -1;
              if (-1 === value) {
                return self.negate();
              } else {
                tmp21 = globalThis;
                _Math = Math;
                absolute = Math.abs(value);
                num4 = 10000000;
                if (absolute < 10000000) {
                  tmp13 = BigInteger;
                  tmp14 = multiplySmall;
                  prototype3 = BigInteger.prototype;
                  tmp15 = new.target;
                  tmp16 = new.target;
                  tmp17 = tmp;
                  tmp18 = new BigInteger(multiplySmall(value, absolute), tmp);
                  tmp19 = tmp18;
                  return tmp18;
                } else {
                  tmp23 = smallToArray;
                  arr2 = smallToArray(absolute);
                }
              }
            }
          }
        }
        length = value.length;
        length2 = arr2.length;
        if (-0.012 * length - 0.012 * length2 + 0.000015 * length * length2 > 0) {
          tmp8 = BigInteger;
          tmp9 = multiplyKaratsuba;
          prototype2 = BigInteger.prototype;
          tmp10 = new.target;
          tmp11 = new.target;
          tmp12 = tmp;
          tmp7 = new BigInteger(multiplyKaratsuba(value, arr2), tmp);
        } else {
          tmp2 = BigInteger;
          tmp3 = multiplyLong;
          prototype = BigInteger.prototype;
          tmp4 = new.target;
          tmp5 = new.target;
          tmp6 = tmp;
          tmp7 = new BigInteger(multiplyLong(value, arr2), tmp);
        }
        return tmp7;
      }
      _multiplyBySmall(arg0) {
        self = this;
        if (0 === arg0.value) {
          tmp6 = Integer;
          first = Integer[0];
        } else {
          num = 1;
          first = self;
          if (1 !== arg0.value) {
            num2 = -1;
            if (-1 === arg0.value) {
              negateResult = self.negate();
            } else {
              tmp2 = multiplySmallAndArray;
              tmp3 = globalThis;
              _Math = Math;
              negateResult = multiplySmallAndArray(Math.abs(arg0.value), self.value, self.sign !== arg0.sign);
            }
            tmp5 = negateResult;
          }
        }
        return first;
      }
      square() {
        tmp = new BigInteger(square(this.value), false);
        return tmp;
      }
      divmod(arg0) {
        tmp = divModAny(this, arg0);
        obj = { quotient: tmp[0], remainder: tmp[1] };
        return obj;
      }
      divide(arg0) {
        return divModAny(this, arg0)[0];
      }
      mod(arg0) {
        return divModAny(this, arg0)[1];
      }
      pow(arg0) {
        self = this;
        iter = parseValue(arg0);
        value = this.value;
        value = iter.value;
        if (0 === value) {
          tmp26 = Integer;
          num2 = 1;
          return Integer[1];
        } else if (0 === value) {
          tmp25 = Integer;
          return Integer[0];
        } else {
          num3 = 1;
          if (1 === value) {
            tmp24 = Integer;
            return Integer[1];
          } else {
            num4 = -1;
            if (-1 === value) {
              tmp23 = Integer;
              return iter.isEven() ? tmp23[1] : tmp23[-1];
            } else if (iter.sign) {
              tmp22 = Integer;
              return Integer[0];
            } else if (iter.isSmall) {
              if (self.isSmall) {
                tmp6 = isPrecise;
                tmp7 = globalThis;
                _Math = Math;
                powResult = Math.pow(value, value);
                if (isPrecise(powResult)) {
                  tmp16 = SmallInteger;
                  tmp17 = truncate;
                  prototype2 = SmallInteger.prototype;
                  tmp18 = new.target;
                  tmp19 = new.target;
                  tmp20 = new SmallInteger(truncate(powResult));
                  tmp21 = tmp20;
                  return tmp20;
                }
              }
              tmp9 = Integer;
              obj = Integer[1];
              flag = true;
              timesResult = obj;
              diff = value;
              if (true & value) {
                timesResult = obj.times(self);
                diff = value - 1;
              }
              num = 2;
              obj2 = self;
              obj3 = timesResult;
              tmp12 = timesResult;
              if (0 !== diff) {
                do {
                  result = diff / 2;
                  squareResult = obj2.square();
                  timesResult1 = obj3;
                  diff = result;
                  if (true & result) {
                    timesResult1 = obj3.times(squareResult);
                    diff = result - 1;
                  }
                  obj3 = timesResult1;
                  obj2 = squareResult;
                  tmp12 = timesResult1;
                } while (0 !== diff);
              }
              return tmp12;
            } else {
              tmp = globalThis;
              _Error = Error;
              str = "The exponent ";
              prototype = Error.prototype;
              tmp2 = new.target;
              str2 = " is too large.";
              tmp3 = new.target;
              error = new Error("The exponent " + iter.toString() + " is too large.");
              tmp5 = error;
              throw error;
            }
          }
        }
      }
      modPow(arg0, arg1) {
        self = this;
        obj = parseValue(arg0);
        obj2 = parseValue(arg1);
        if (obj2.isZero()) {
          tmp8 = globalThis;
          _Error = Error;
          prototype = Error.prototype;
          tmp9 = new.target;
          str = "Cannot take modPow with modulus 0";
          tmp10 = new.target;
          error = new Error("Cannot take modPow with modulus 0");
          tmp12 = error;
          throw error;
        } else {
          tmp = Integer;
          num = 1;
          tmp2 = Integer[1];
          modResult = self.mod(obj2);
          multiplyResult = obj;
          modInvResult = modResult;
          if (obj.isNegative()) {
            tmp3 = Integer;
            num2 = -1;
            multiplyResult = obj.multiply(Integer[-1]);
            modInvResult = modResult.modInv(obj2);
          }
          num3 = 2;
          obj6 = multiplyResult;
          obj7 = tmp2;
          tmp4 = tmp2;
          if (multiplyResult.isPositive()) {
            tmp5 = modInvResult;
            while (!modInvResult.isZero()) {
              modResult1 = obj7;
              if (obj6.isOdd()) {
                multiplyResult1 = obj7.multiply(modInvResult);
                modResult1 = multiplyResult1.mod(obj2);
              }
              divideResult = obj6.divide(2);
              squareResult = modInvResult.square();
              modInvResult = squareResult.mod(obj2);
              obj7 = modResult1;
              obj6 = divideResult;
              tmp4 = modResult1;
            }
            tmp7 = Integer;
            num4 = 0;
            return Integer[0];
          }
          return tmp4;
        }
      }
      compareAbs(arg0) {
        tmp = parseValue(arg0);
        num = 1;
        if (!tmp.isSmall) {
          tmp4 = compareAbs;
          num = compareAbs(tmp2, tmp3);
        }
        return num;
      }
      compare(arg0) {
        self = this;
        if (arg0 === Infinity) {
          num5 = -1;
          return -1;
        } else {
          num6 = -Infinity;
          if (arg0 === -Infinity) {
            num4 = 1;
            return 1;
          } else {
            tmp4 = parseValue;
            tmp5 = parseValue(arg0);
            if (self.sign !== tmp5.sign) {
              num3 = -1;
              if (tmp5.sign) {
                num3 = 1;
              }
              result = num3;
            } else if (tmp5.isSmall) {
              num2 = 1;
              if (self.sign) {
                num2 = -1;
              }
              result = num2;
            } else {
              tmp = compareAbs;
              num = 1;
              tmp2 = compareAbs(tmp6, tmp7);
              if (self.sign) {
                num = -1;
              }
              result = tmp2 * num;
            }
            return result;
          }
        }
      }
      equals(arg0) {
        return 0 === this.compare(arg0);
      }
      notEquals(arg0) {
        return 0 !== this.compare(arg0);
      }
      greater(arg0) {
        return this.compare(arg0) > 0;
      }
      lesser(arg0) {
        return this.compare(arg0) < 0;
      }
      greaterOrEquals(arg0) {
        return this.compare(arg0) >= 0;
      }
      lesserOrEquals(arg0) {
        return this.compare(arg0) <= 0;
      }
      isEven() {
        return !(1 & this.value[0]);
      }
      isOdd() {
        return !(1 & ~this.value[0]);
      }
      isPositive() {
        return !this.sign;
      }
      isNegative() {
        return this.sign;
      }
      isUnit() {
        return false;
      }
      isZero() {
        return false;
      }
      isDivisibleBy(arg0) {
        self = this;
        obj = parseValue(arg0);
        tmp = !obj.isZero();
        if (tmp) {
          tmp2 = !obj.isUnit();
          if (!tmp2) {
            tmp = !tmp2;
          } else {
            num = 2;
            num2 = 0;
            if (0 === obj.compareAbs(2)) {
              isEvenResult = self.isEven();
            } else {
              modResult = self.mod(obj);
              isEvenResult = modResult.isZero();
            }
            tmp4 = isEvenResult;
          }
        }
        return tmp;
      }
      isPrime(arg0) {
        self = this;
        tmp = isBasicPrime(this);
        if (tmp !== closure_0) {
          return tmp;
        } else {
          absResult = self.abs();
          bitLengthResult = absResult.bitLength();
          num2 = 64;
          if (bitLengthResult <= 64) {
            tmp7 = millerRabinTest;
            return millerRabinTest(absResult, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
          } else {
            tmp8 = globalThis;
            _Math2 = Math;
            num3 = 2;
            logResult = Math.log(2);
            result = logResult * bitLengthResult.toJSNumber();
            flag = true;
            tmp11 = arg0;
            result1 = result;
            if (true === arg0) {
              _Math = Math;
              result1 = 2 * Math.pow(result, 2);
            }
            rounded = Math.ceil(result1);
            items = [];
            for (let num = 0; num < rounded; num = num + 1) {
              tmp4 = outer1_0;
              arr = items.push(outer1_0(num + 2));
            }
            tmp6 = millerRabinTest;
            return millerRabinTest(absResult, items);
          }
        }
      }
      isProbablePrime(arg0, arg1) {
        self = this;
        tmp = isBasicPrime(this);
        if (tmp !== closure_0) {
          return tmp;
        } else {
          absResult = self.abs();
          tmp2 = closure_0;
          num = 5;
          if (arg0 !== closure_0) {
            num = arg0;
          }
          items = [];
          num2 = 0;
          num3 = 2;
          if (0 < num) {
            do {
              tmp3 = outer1_0;
              arr = items.push(outer1_0.randBetween(2, absResult.minus(2), arg1));
              num2 = num2 + 1;
            } while (num2 < num);
          }
          tmp5 = millerRabinTest;
          return millerRabinTest(absResult, items);
        }
      }
      modInv(arg0) {
        self = this;
        zero = outer1_0.zero;
        one = outer1_0.one;
        obj = parseValue(arg0);
        absResult = this.abs();
        obj3 = zero;
        obj4 = obj;
        if (!absResult.isZero()) {
          do {
            divideResult = obj.divide(absResult);
            subtractResult = zero.subtract(divideResult.multiply(one));
            subtractResult1 = obj.subtract(divideResult.multiply(absResult));
            zero = one;
            obj = absResult;
            one = subtractResult;
            absResult = subtractResult1;
            obj3 = zero;
            obj4 = obj;
            isZeroResult = subtractResult1.isZero();
          } while (!isZeroResult);
        }
        if (obj4.isUnit()) {
          num = 0;
          num2 = -1;
          addResult = obj3;
          if (-1 === obj3.compare(0)) {
            addResult = obj3.add(arg0);
          }
          negateResult = addResult;
          if (self.isNegative()) {
            negateResult = addResult.negate();
          }
          return negateResult;
        } else {
          tmp3 = globalThis;
          _Error = Error;
          str = " and ";
          text = `${self.toString()} and `;
          prototype = Error.prototype;
          tmp5 = new.target;
          str2 = " are not co-prime";
          tmp6 = new.target;
          error = new Error(`${self.toString()} and ` + arg0.toString() + " are not co-prime");
          tmp8 = error;
          throw error;
        }
      }
      next() {
        self = this;
        value = this.value;
        if (this.sign) {
          tmp6 = subtractSmall;
          num2 = 1;
          tmp5 = subtractSmall(value, 1, self.sign);
        } else {
          tmp = BigInteger;
          tmp2 = addSmall;
          num = 1;
          prototype = BigInteger.prototype;
          tmp3 = new.target;
          tmp4 = new.target;
          tmp5 = new BigInteger(addSmall(value, 1), self.sign);
        }
        return tmp5;
      }
      prev() {
        value = this.value;
        if (this.sign) {
          tmp4 = BigInteger;
          tmp5 = addSmall;
          num2 = 1;
          prototype = BigInteger.prototype;
          tmp6 = new.target;
          flag = true;
          tmp7 = new.target;
          tmp3 = new BigInteger(addSmall(value, 1), true);
        } else {
          tmp2 = subtractSmall;
          num = 1;
          tmp3 = subtractSmall(value, 1, tmp.sign);
        }
        return tmp3;
      }
      shiftLeft(arg0) {
        self = this;
        obj = parseValue(arg0);
        toJSNumberResult = obj.toJSNumber();
        if (shift_isSmall(toJSNumberResult)) {
          num = 0;
          if (toJSNumberResult < 0) {
            return self.shiftRight(-toJSNumberResult);
          } else if (self.isZero()) {
            return self;
          } else {
            tmp7 = length;
            num2 = 1;
            diff = toJSNumberResult;
            multiplyResult = self;
            obj3 = self;
            tmp9 = toJSNumberResult;
            if (toJSNumberResult >= length) {
              do {
                tmp10 = length;
                multiplyResult = multiplyResult.multiply(length);
                tmp11 = length;
                diff = diff - (length - 1);
                tmp12 = length;
                obj3 = multiplyResult;
                tmp9 = diff;
              } while (diff >= length);
            }
            tmp13 = Object;
            return obj3.multiply(Object[tmp9]);
          }
        } else {
          tmp2 = globalThis;
          _Error = Error;
          _String = String;
          str = " is too large for shifting.";
          prototype = Error.prototype;
          tmp3 = new.target;
          tmp4 = new.target;
          error = new Error(String(toJSNumberResult) + " is too large for shifting.");
          tmp6 = error;
          throw error;
        }
      }
      shiftRight(arg0) {
        self = this;
        obj = parseValue(arg0);
        toJSNumberResult = obj.toJSNumber();
        if (shift_isSmall(toJSNumberResult)) {
          num = 0;
          if (toJSNumberResult < 0) {
            return self.shiftLeft(-toJSNumberResult);
          } else {
            tmp21 = length;
            num2 = 1;
            diff = toJSNumberResult;
            obj4 = self;
            tmp15 = self;
            tmp16 = toJSNumberResult;
            if (toJSNumberResult >= length) {
              tmp7 = obj4;
              while (!obj4.isZero()) {
                if (!obj4.isNegative()) {
                  tmp8 = divModAny;
                  tmp9 = length;
                  tmp10 = divModAny(obj4, length);
                  [obj3, obj2] = tmp10;
                  if (obj2.isNegative()) {
                    prevResult = obj3.prev();
                  } else {
                    prevResult = obj3;
                  }
                  tmp12 = length;
                  diff = diff - (length - 1);
                  tmp14 = length;
                  obj4 = prevResult;
                  tmp15 = prevResult;
                  tmp16 = diff;
                } else if (obj4.isUnit()) {
                  break;
                }
                return obj4;
              }
            }
            tmp17 = divModAny;
            tmp18 = Object;
            tmp19 = divModAny(tmp15, Object[tmp16]);
            [obj6, obj5] = tmp19;
            if (obj5.isNegative()) {
              prevResult1 = obj6.prev();
            } else {
              prevResult1 = obj6;
            }
            return prevResult1;
          }
        } else {
          tmp2 = globalThis;
          _Error = Error;
          _String = String;
          str = " is too large for shifting.";
          prototype = Error.prototype;
          tmp3 = new.target;
          tmp4 = new.target;
          error = new Error(String(toJSNumberResult) + " is too large for shifting.");
          tmp6 = error;
          throw error;
        }
      }
      not() {
        negateResult = this.negate();
        return negateResult.prev();
      }
      and(arg0) {
        return bitwise(this, arg0, (arg0, arg1) => arg0 & arg1);
      }
      or(arg0) {
        return bitwise(this, arg0, (arg0, arg1) => arg0 | arg1);
      }
      xor(arg0) {
        return bitwise(this, arg0, (arg0, arg1) => arg0 ^ arg1);
      }
      bitLength() {
        self = this;
        self2 = this;
        if (this.compareTo(outer1_0(0)) < 0) {
          negateResult = self.negate();
          tmp = outer1_0;
          num = 1;
          self2 = negateResult.subtract(outer1_0(1));
        }
        if (0 === self2.compareTo(outer1_0(0))) {
          tmp6 = outer1_0;
          addResult = outer1_0(0);
        } else {
          tmp2 = outer1_0;
          tmp3 = integerLogarithm;
          num2 = 2;
          obj2 = outer1_0(integerLogarithm(self2, outer1_0(2)).e);
          tmp4 = outer1_0;
          num3 = 1;
          addResult = obj2.add(outer1_0(1));
        }
        return addResult;
      }
      toArray(arg0) {
        return toBase(this, arg0);
      }
      toString(arg0, arg1) {
        num = arg0;
        self = this;
        if (arg0 === closure_0) {
          num = 10;
        }
        if (10 !== num) {
          tmp4 = toBaseString;
          tmp5 = arg1;
          return toBaseString(self, num, arg1);
        } else {
          value = self.value;
          tmp6 = globalThis;
          _String2 = String;
          diff = value.length - 1;
          StringResult = String(value[diff]);
          diff1 = diff - 1;
          str2 = "0000000";
          num2 = 0;
          sum = StringResult;
          tmp3 = StringResult;
          if (diff1 >= 0) {
            do {
              _String = String;
              StringResult1 = String(value[diff1]);
              slice = "0000000".slice;
              sum = sum + ("0000000".slice(StringResult1.length) + StringResult1);
              diff1 = diff1 - 1;
              tmp3 = sum;
            } while (diff1 >= 0);
          }
          str = "";
          if (self.sign) {
            str = "-";
          }
          return str + tmp3;
        }
      }
      valueOf() {
        return parseInt(this.toString(), 10);
      }
    }
    num = num + 1;
    class SmallInteger {
      constructor(arg0) {
        this.value = arg0;
        this.sign = arg0 < 0;
        this.isSmall = true;
        return;
      }
      add(arg0) {
        self = this;
        iter = parseValue(arg0);
        value = this.value;
        if (value < 0 !== iter.sign) {
          return self.subtract(iter.negate());
        } else {
          value = iter.value;
          tmp4 = value;
          if (iter.isSmall) {
            tmp = isPrecise;
            if (isPrecise(value + value)) {
              tmp12 = SmallInteger;
              prototype2 = SmallInteger.prototype;
              tmp13 = new.target;
              tmp14 = new.target;
              tmp15 = new SmallInteger(value + value);
              tmp16 = tmp15;
              return tmp15;
            } else {
              tmp2 = smallToArray;
              tmp3 = globalThis;
              _Math = Math;
              tmp4 = smallToArray(Math.abs(value));
            }
          }
          tmp5 = BigInteger;
          tmp6 = addSmall;
          tmp7 = globalThis;
          _Math2 = Math;
          prototype = BigInteger.prototype;
          tmp8 = new.target;
          tmp9 = new.target;
          tmp10 = new BigInteger(addSmall(tmp4, Math.abs(value)), value < 0);
          tmp11 = tmp10;
          return tmp10;
        }
      }
      subtract(arg0) {
        self = this;
        iter = parseValue(arg0);
        value = this.value;
        if (value < 0 !== iter.sign) {
          return self.add(iter.negate());
        } else {
          value = iter.value;
          if (iter.isSmall) {
            tmp4 = SmallInteger;
            prototype = SmallInteger.prototype;
            tmp5 = new.target;
            tmp6 = new.target;
            tmp3 = new SmallInteger(value - value);
          } else {
            tmp = subtractSmall;
            tmp2 = globalThis;
            _Math = Math;
            tmp3 = subtractSmall(value, Math.abs(value), value >= 0);
          }
          return tmp3;
        }
      }
      negate() {
        tmp = new SmallInteger(-this.value);
        tmp.sign = !this.sign;
        return tmp;
      }
      abs() {
        tmp = new SmallInteger(Math.abs(this.value));
        return tmp;
      }
      _multiplyBySmall(arg0) {
        self = this;
        if (isPrecise(arg0.value * this.value)) {
          tmp6 = SmallInteger;
          prototype = SmallInteger.prototype;
          tmp7 = new.target;
          tmp8 = new.target;
          tmp5 = new SmallInteger(arg0.value * self.value);
        } else {
          tmp = multiplySmallAndArray;
          tmp2 = globalThis;
          _Math = Math;
          tmp4 = smallToArray;
          _Math2 = Math;
          absolute = Math.abs(arg0.value);
          tmp5 = multiplySmallAndArray(absolute, smallToArray(Math.abs(self.value)), self.sign !== arg0.sign);
        }
        return tmp5;
      }
      multiply(arg0) {
        obj = parseValue(arg0);
        return obj._multiplyBySmall(this);
      }
      square() {
        result = this.value * this.value;
        if (isPrecise(result)) {
          tmp9 = SmallInteger;
          prototype2 = SmallInteger.prototype;
          tmp10 = new.target;
          tmp11 = new.target;
          tmp12 = result;
          tmp8 = new SmallInteger(result);
        } else {
          tmp2 = BigInteger;
          tmp3 = square;
          tmp4 = smallToArray;
          tmp5 = globalThis;
          _Math = Math;
          prototype = BigInteger.prototype;
          tmp6 = new.target;
          flag = false;
          tmp7 = new.target;
          tmp8 = new BigInteger(square(smallToArray(Math.abs(this.value))), false);
        }
        return tmp8;
      }
      compareAbs(arg0) {
        tmp = parseValue(arg0);
        absolute = Math.abs(this.value);
        num = -1;
        num2 = -1;
        if (tmp.isSmall) {
          _Math = Math;
          absolute1 = Math.abs(tmp3);
          num3 = 0;
          if (absolute !== absolute1) {
            if (absolute > absolute1) {
              num = 1;
            }
            num3 = num;
          }
          num2 = num3;
        }
        return num2;
      }
      compare(arg0) {
        if (arg0 === Infinity) {
          num6 = -1;
          return -1;
        } else {
          num7 = -Infinity;
          if (arg0 === -Infinity) {
            num5 = 1;
            return 1;
          } else {
            tmp = parseValue;
            iter = parseValue(arg0);
            self = this;
            value = this.value;
            value = iter.value;
            num8 = 0;
            if (iter.isSmall) {
              num3 = 0;
              if (value != value) {
                num4 = -1;
                if (value > value) {
                  num4 = 1;
                }
                num3 = num4;
              }
              num = num3;
            } else if (value < 0 !== iter.sign) {
              num2 = 1;
              if (value < 0) {
                num2 = -1;
              }
              num = num2;
            } else {
              num = -1;
              if (value < 0) {
                num = 1;
              }
            }
            return num;
          }
        }
      }
      isEven() {
        return !(1 & this.value);
      }
      isOdd() {
        return !(1 & ~this.value);
      }
      isPositive() {
        return this.value > 0;
      }
      isNegative() {
        return this.value < 0;
      }
      isUnit() {
        return 1 === Math.abs(this.value);
      }
      isZero() {
        return 0 === this.value;
      }
      next() {
        value = this.value;
        if (value + 1 < 9007199254740992) {
          tmp6 = SmallInteger;
          prototype2 = SmallInteger.prototype;
          tmp7 = new.target;
          tmp8 = new.target;
          tmp5 = new SmallInteger(value + 1);
        } else {
          tmp = BigInteger;
          tmp2 = c1;
          prototype = BigInteger.prototype;
          tmp3 = new.target;
          flag = false;
          tmp4 = new.target;
          tmp5 = new BigInteger(c1, false);
        }
        return tmp5;
      }
      prev() {
        value = this.value;
        if (value - 1 > -9007199254740992) {
          tmp6 = SmallInteger;
          prototype2 = SmallInteger.prototype;
          tmp7 = new.target;
          tmp8 = new.target;
          tmp5 = new SmallInteger(value - 1);
        } else {
          tmp = BigInteger;
          tmp2 = c1;
          prototype = BigInteger.prototype;
          tmp3 = new.target;
          flag = true;
          tmp4 = new.target;
          tmp5 = new BigInteger(c1, true);
        }
        return tmp5;
      }
      toArray(arg0) {
        return toBase(this, arg0);
      }
      toString(arg0, arg1) {
        num = arg0;
        self = this;
        if (arg0 === closure_0) {
          num = 10;
        }
        if (10 != num) {
          tmp3 = toBaseString;
          tmp4 = arg1;
          StringResult = toBaseString(self, num, arg1);
        } else {
          tmp = globalThis;
          _String = String;
          StringResult = String(self.value);
        }
        return StringResult;
      }
      valueOf() {
        return this.value;
      }
    }
  }
  [Integer.zero, Integer.one] = Integer;
  Integer.minusOne = Integer[-1];
  Integer.max = max;
  Integer.min = min;
  Integer.gcd = gcd;
  Integer.lcm = function lcm(arg0, arg1) {
    const absResult = parseValue(arg0).abs();
    const obj = parseValue(arg0);
    const absResult1 = parseValue(arg1).abs();
    const obj3 = parseValue(arg1);
    return absResult.divide(gcd(absResult, absResult1)).multiply(absResult1);
  };
  Integer.isInstance = (arg0) => {
    let tmp = arg0 instanceof BigInteger;
    if (!tmp) {
      tmp = arg0 instanceof SmallInteger;
    }
    if (!tmp) {
      tmp = arg0 instanceof NativeBigInt;
    }
    return tmp;
  };
  Integer.randBetween = function randBetween(arg0, absResult, arg2) {
    let random = arg2;
    const tmp = parseValue(arg0);
    const tmp2 = parseValue(absResult);
    if (!arg2) {
      const _Math = Math;
      random = Math.random;
    }
    const obj = min(tmp, tmp2);
    const obj2 = max(tmp, tmp2);
    const addResult = max(tmp, tmp2).subtract(obj).add(1);
    if (addResult.isSmall) {
      const _Math2 = Math;
      return obj.add(Math.floor(random() * addResult));
    } else {
      const value = toBase(addResult, 10000000).value;
      const items = [];
      let num2 = 0;
      let flag2 = true;
      if (0 < value.length) {
        do {
          let num3 = 10000000;
          if (flag2) {
            num3 = value[num2];
          }
          let tmp6 = truncate;
          let tmp7 = truncate(random() * num3);
          let arr = items.push(tmp7);
          if (tmp7 < num3) {
            flag2 = false;
          }
          num2 = num2 + 1;
        } while (num2 < value.length);
      }
      return obj.add(Integer.fromArray(items, 10000000, false));
    }
    const subtractResult = max(tmp, tmp2).subtract(obj);
  };
  Integer.fromArray = (arr) => {
    let num = arg1;
    const mapped = arr.map(parseValue);
    if (!arg1) {
      num = 10;
    }
    return parseBaseFromArray(mapped, parseValue(num), arg2);
  };
  return Integer;
})();
let closure_0 = tmp;
let hasOwnPropertyResult = undefined !== module;
if (hasOwnPropertyResult) {
  hasOwnPropertyResult = module.hasOwnProperty("exports");
}
if (hasOwnPropertyResult) {
  module.exports = tmp;
}
let amd = "function" === typeof globalThis.define;
if (amd) {
  amd = globalThis.define.amd;
}
if (amd) {
  globalThis.define(() => closure_0);
}