// Module ID: 14
// Function ID: 15
// Name: Integer
// Dependencies: []

// Module 14 (Integer)
class Integer {
  constructor(arg0, arg1, arg2, arg3) {
    if (undefined === arg0) {
      tmp32 = Integer;
      first = Integer[0];
    } else {
      tmp33 = arg1;
      if (undefined !== arg1) {
        str = arg2;
        num = 10;
        if (10 === +arg1) {
        }
        tmp3 = parseBase;
        if (typeof parseBase !== "function") {
          str10 = "Trying to call a non-function";
          throwTypeErrorResult = HermesBuiltin.throwTypeError();
        }
        if (!str) {
          str = c1;
        }
        tmp4 = arg3;
        tmp5 = globalThis;
        _String = String;
        str2 = String(arg0);
        formatted1 = str;
        formatted = str2;
        if (!arg3) {
          formatted = str2.toLowerCase();
          formatted1 = str.toLowerCase();
        }
        length = formatted.length;
        _Math = Math;
        absolute = Math.abs(arg1);
        obj = {};
        num2 = 0;
        num3 = 1;
        num4 = 0;
        if (0 < formatted1.length) {
          do {
            obj[formatted1[num4]] = num4;
            num4 = num4 + 1;
            length2 = formatted1.length;
          } while (num4 < length2);
        }
        str3 = "1";
        str4 = "-";
        num5 = 0;
        if (0 < length) {
          while (true) {
            tmp7 = formatted[num5];
            tmp8 = num5;
            if ("-" !== tmp7) {
              if (tmp7 in obj) {
                if (obj[tmp7] >= absolute) {
                  if ("1" !== tmp7) {
                    break;
                  } else if (1 !== absolute) {
                    break;
                  }
                }
              }
            }
            num5 = num5 + 1;
          }
          _Error = Error;
          str5 = " is not a valid digit in base ";
          tmp9 = new.target;
          str6 = ".";
          tmp10 = new.target;
          error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
          tmp12 = error;
          throw error;
        }
        tmp13 = parseValue;
        tmp15 = "-" === formatted[0];
        num6 = 0;
        tmp14 = parseValue(arg1);
        if (tmp15) {
          num6 = 1;
        }
        items = [];
        str7 = "<";
        str8 = ">";
        if (num6 < formatted.length) {
          while (true) {
            tmp16 = formatted[num6];
            tmp17 = num6;
            if (tmp16 in obj) {
              tmp26 = parseValue;
              arr = items.push(parseValue(obj[tmp16]));
              sum = num6;
            } else {
              tmp18 = num6;
              if ("<" !== tmp16) {
                break;
              } else {
                sum = tmp18 + 1;
                while (">" !== formatted[sum]) {
                  tmp18 = sum;
                  if (sum >= formatted.length) {
                    break;
                  }
                }
                tmp20 = parseValue;
                arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
              }
            }
            num6 = sum + 1;
          }
          _Error2 = Error;
          str9 = " is not a valid character";
          tmp22 = new.target;
          tmp23 = new.target;
          error1 = new Error(tmp16 + " is not a valid character");
          tmp25 = error1;
          throw error1;
        }
        tmp28 = Integer;
        [tmp29, obj2] = Integer;
        diff = items.length - 1;
        addResult = tmp29;
        obj4 = tmp29;
        if (0 <= diff) {
          do {
            obj5 = items[diff];
            addResult = addResult.add(obj5.times(timesResult));
            timesResult = timesResult.times(tmp14);
            diff = diff - 1;
            obj4 = addResult;
          } while (0 <= diff);
        }
        negateResult = obj4;
        if (tmp15) {
          negateResult = obj4.negate();
        }
        first = negateResult;
      }
      tmp = parseValue;
      first = parseValue(arg0);
    }
    return first;
  }
}
class BigInteger {
  constructor(arg0, arg1) {
    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;
      tmp17 = BigInteger;
      if (iter.isSmall) {
        tmp4 = globalThis;
        _Math = Math;
        absolute = Math.abs(value);
        length = value.length;
        _Array = Array;
        tmp6 = new.target;
        tmp7 = new.target;
        tmp8 = length;
        array = new Array(length);
        tmp10 = array;
        num2 = 0;
        num3 = 10000000;
        num4 = 1;
        num5 = 0;
        sum1 = absolute;
        num6 = 0;
        rounded1 = absolute;
        if (0 < length) {
          do {
            sum = value[num5] - 10000000 + sum1;
            _Math2 = Math;
            rounded = Math.floor(sum / 10000000);
            array[num5] = sum - rounded * 10000000;
            sum1 = rounded + 1;
            num5 = num5 + 1;
            rounded1 = sum1;
            num6 = num5;
          } while (num5 < length);
        }
        if (rounded1 > 0) {
          do {
            array[num6] = rounded1 % 10000000;
            _Math3 = Math;
            sum2 = num6 + 1;
            rounded1 = Math.floor(rounded1 / 10000000);
            num6 = sum2;
          } while (rounded1 > 0);
        }
        obj = Object.create(tmp17.prototype);
        obj1 = {};
        obj1.value = array;
        obj1.sign = self.sign;
        flag2 = false;
        obj1.isSmall = false;
        obj = obj1;
      } else {
        tmp = addAny;
        num = 0;
        tmp2 = addAny(value, value);
        obj2 = Object.create(tmp17.prototype);
        obj = {};
        obj.value = tmp2;
        obj.sign = self.sign;
        flag = false;
        obj.isSmall = false;
      }
      return obj;
    }
  }
  subtract(arg0) {
    self = this;
    iter = parseValue(arg0);
    if (this.sign !== iter.sign) {
      return self.add(iter.negate());
    } else {
      value = self.value;
      value1 = iter.value;
      if (iter.isSmall) {
        tmp12 = subtractSmall;
        tmp13 = globalThis;
        _Math = Math;
        num7 = 0;
        obj2 = subtractSmall(value, Math.abs(value1), self.sign);
      } else {
        sign = self.sign;
        if (value.length !== value1.length) {
          num5 = -1;
          if (value.length > value1.length) {
            num5 = 1;
          }
          num3 = num5;
        } else {
          num = 1;
          diff = value.length - 1;
          num2 = 0;
          num3 = 0;
          if (0 <= diff) {
            tmp2 = diff;
            while (value[diff] === value1[diff]) {
              diff = diff - 1;
              num3 = 0;
            }
            num4 = -1;
            if (value[diff] > value1[diff]) {
              num4 = 1;
            }
            num3 = num4;
          }
        }
        num6 = 0;
        if (0 <= num3) {
          tmp6 = subtract;
          tmp4 = subtract(value, value1);
          tmp5 = sign;
        } else {
          tmp3 = subtract;
          tmp4 = subtract(value1, value);
          tmp5 = !sign;
        }
        tmp7 = arrayToSmall;
        tmp8 = arrayToSmall(tmp4);
        if (typeof tmp8 === "number") {
          tmp9 = tmp8;
          if (tmp5) {
            tmp9 = -tmp8;
          }
          tmp10 = SmallInteger;
          obj = Object.create(SmallInteger.prototype);
          obj = {};
          obj.value = tmp9;
          obj.sign = tmp9 < 0;
          flag = true;
          obj.isSmall = true;
          obj2 = obj;
        } else {
          tmp14 = BigInteger;
          obj1 = Object.create(BigInteger.prototype);
          obj2 = {};
          obj2.value = tmp8;
          obj2.sign = tmp5;
          flag2 = false;
          obj2.isSmall = false;
        }
      }
      return obj2;
    }
  }
  negate() {
    sign = !this.sign;
    obj = Object.create(BigInteger.prototype);
    return { value: this.value, sign, isSmall: false };
  }
  abs() {
    obj = Object.create(BigInteger.prototype);
    return { value: this.value, sign: false, isSmall: false };
  }
  multiply(arg0) {
    self = this;
    iter = parseValue(arg0);
    value = this.value;
    value1 = iter.value;
    tmp = this.sign !== iter.sign;
    if (!iter.isSmall) {
      length = value.length;
      length2 = value1.length;
      num2 = -0.012;
      num3 = 0.012;
      num4 = 0.000015;
      num5 = 0;
      if (0 < -0.012 * length - 0.012 * length2 + 0.000015 * length * length2) {
        tmp7 = BigInteger;
        tmp8 = multiplyKaratsuba;
        tmp9 = multiplyKaratsuba(value, value1);
        obj = Object.create(BigInteger.prototype);
        obj1 = {};
        obj1.value = tmp9;
        obj1.sign = tmp;
        flag2 = false;
        obj1.isSmall = false;
        obj = obj1;
      } else {
        tmp3 = BigInteger;
        tmp4 = multiplyLong;
        tmp5 = multiplyLong(value, value1);
        obj2 = Object.create(BigInteger.prototype);
        obj = {};
        obj.value = tmp5;
        obj.sign = tmp;
        flag = false;
        obj.isSmall = false;
      }
      return obj;
    } else {
      num = 0;
      if (0 === value1) {
        tmp21 = Integer;
        return Integer[0];
      } else {
        num10 = 1;
        if (1 === value1) {
          return self;
        } else {
          num11 = -1;
          if (-1 === value1) {
            return self.negate();
          } else {
            tmp22 = globalThis;
            _Math6 = Math;
            absolute = Math.abs(value1);
            num12 = 10000000;
            if (absolute < 10000000) {
              length3 = value.length;
              _Array = Array;
              tmp12 = new.target;
              tmp13 = new.target;
              tmp14 = length3;
              tmp11 = BigInteger;
              array = new Array(length3);
              tmp16 = array;
              num6 = 0;
              num7 = 0;
              num8 = 0;
              num9 = 0;
              if (0 < length3) {
                do {
                  sum = value[num7] * absolute + num6;
                  _Math4 = Math;
                  rounded = Math.floor(sum / 10000000);
                  array[num7] = sum - rounded * 10000000;
                  num7 = num7 + 1;
                  num6 = rounded;
                  num8 = rounded;
                  num9 = num7;
                } while (num7 < length3);
              }
              if (num8 > 0) {
                do {
                  array[num9] = num8 % 10000000;
                  _Math5 = Math;
                  sum1 = num9 + 1;
                  num8 = Math.floor(num8 / 10000000);
                  num9 = sum1;
                } while (num8 > 0);
              }
              obj3 = Object.create(tmp11.prototype);
              obj4 = {};
              obj4.value = array;
              obj4.sign = tmp;
              flag3 = false;
              obj4.isSmall = false;
              return obj4;
            } else {
              if (absolute < 10000000) {
                items = [];
                items[0] = absolute;
                items2 = items;
              } else {
                num13 = 100000000000000;
                if (absolute < 100000000000000) {
                  items1 = [, ];
                  items1[0] = absolute % 10000000;
                  _Math3 = Math;
                  items1[1] = Math.floor(absolute / 10000000);
                  items2 = items1;
                } else {
                  items2 = [, , ];
                  items2[0] = absolute % 10000000;
                  _Math = Math;
                  items2[1] = Math.floor(absolute / 10000000) % 10000000;
                  _Math2 = Math;
                  items2[2] = Math.floor(absolute / 100000000000000);
                }
              }
              tmp2 = items2;
            }
          }
        }
      }
    }
    return;
  }
  _multiplyBySmall(arg0) {
    if (0 === arg0.value) {
      tmp5 = Integer;
      self2 = Integer[0];
    } else {
      self = this;
      num = 1;
      self2 = this;
      if (1 !== arg0.value) {
        num2 = -1;
        if (-1 === arg0.value) {
          negateResult = self.negate();
        } else {
          tmp = multiplySmallAndArray;
          tmp2 = globalThis;
          _Math = Math;
          negateResult = multiplySmallAndArray(Math.abs(arg0.value), self.value, self.sign !== arg0.sign);
        }
        tmp4 = negateResult;
      }
    }
    return self2;
  }
  square() {
    value = square(this.value);
    obj = Object.create(BigInteger.prototype);
    return { value, sign: false, isSmall: false };
  }
  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) {
      tmp25 = Integer;
      return Integer[1];
    } else if (0 === value) {
      tmp24 = Integer;
      return Integer[0];
    } else {
      num4 = 1;
      if (1 === value) {
        tmp23 = Integer;
        return Integer[1];
      } else {
        num5 = -1;
        if (-1 === value) {
          tmp22 = Integer;
          return iter.isEven() ? tmp22[1] : tmp22[-1];
        } else if (iter.sign) {
          tmp21 = Integer;
          return Integer[0];
        } else if (iter.isSmall) {
          if (self.isSmall) {
            tmp6 = globalThis;
            _Math = Math;
            powResult = Math.pow(value, value);
            num = -9007199254740992;
            tmp8 = -9007199254740992 < powResult;
            if (tmp8) {
              num2 = 9007199254740992;
              tmp8 = powResult < 9007199254740992;
            }
            if (tmp8) {
              tmp18 = SmallInteger;
              if (powResult > 0) {
                _Math3 = Math;
                rounded = Math.floor(powResult);
              } else {
                _Math2 = Math;
                rounded = Math.ceil(powResult);
              }
              obj = Object.create(tmp18.prototype);
              obj1 = {};
              obj1.value = rounded;
              obj1.sign = rounded < 0;
              flag2 = true;
              obj1.isSmall = true;
              return obj1;
            }
          }
          tmp9 = Integer;
          obj = Integer[1];
          flag = true;
          diff = value;
          timesResult = obj;
          if (true & value) {
            timesResult = obj.times(self);
            diff = value - 1;
          }
          num3 = 2;
          obj2 = timesResult;
          tmp12 = timesResult;
          if (0 !== diff) {
            do {
              result = diff / 2;
              squareResult = self.square();
              tmp15 = obj2;
              diff1 = result;
              timesResult1 = obj2;
              if (true & result) {
                timesResult1 = obj2.times(squareResult);
                diff1 = result - 1;
              }
              diff = diff1;
              obj2 = timesResult1;
              self = squareResult;
              tmp12 = timesResult1;
            } while (0 !== diff1);
          }
          return tmp12;
        } else {
          tmp = globalThis;
          _Error = Error;
          str = "The exponent ";
          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) {
    obj = parseValue(arg0);
    obj2 = parseValue(arg1);
    if (obj2.isZero()) {
      tmp9 = globalThis;
      _Error = Error;
      tmp10 = new.target;
      str = "Cannot take modPow with modulus 0";
      tmp11 = new.target;
      error = new Error("Cannot take modPow with modulus 0");
      tmp13 = error;
      throw error;
    } else {
      self = this;
      tmp2 = Integer[1];
      tmp = Integer;
      modResult = this.mod(obj2);
      modInvResult = modResult;
      multiplyResult = obj;
      if (obj.isNegative()) {
        num = -1;
        multiplyResult = obj.multiply(tmp[-1]);
        modInvResult = modResult.modInv(obj2);
      }
      num2 = 2;
      obj6 = multiplyResult;
      obj7 = tmp2;
      tmp3 = tmp2;
      if (multiplyResult.isPositive()) {
        tmp4 = modInvResult;
        tmp5 = obj7;
        tmp6 = obj6;
        while (!modInvResult.isZero()) {
          modResult1 = obj7;
          if (obj6.isOdd()) {
            multiplyResult1 = obj7.multiply(modInvResult);
            modResult1 = multiplyResult1.mod(obj2);
          }
          divideResult = require("module_2");
          squareResult = modInvResult.square();
          modInvResult = squareResult.mod(obj2);
          obj7 = modResult1;
          obj6 = divideResult;
          tmp3 = modResult1;
        }
        tmp8 = Integer;
        return Integer[0];
      }
      return tmp3;
    }
  }
  compareAbs(arg0) {
    iter = parseValue(arg0);
    value = this.value;
    value1 = iter.value;
    if (iter.isSmall) {
      return 1;
    } else {
      if (value.length !== value1.length) {
        value = value.length;
        value1 = value1.length;
        num3 = -1;
        if (value > value1) {
          num3 = 1;
        }
        num2 = num3;
      } else {
        diff = value.length - 1;
        num = 0;
        num2 = 0;
        if (0 <= diff) {
          num3 = diff;
          while (value[diff] === value1[diff]) {
            diff = num3 - 1;
            num2 = 0;
          }
        }
        tmp2 = value[num3] > value1[num3];
        num3 = -1;
        if (tmp2) {
          num3 = 1;
        }
        num2 = num3;
      }
      tmp3 = num2;
    }
    return;
  }
  compare(arg0) {
    if (arg0 === Infinity) {
      num10 = -1;
      return -1;
    } else {
      num11 = -Infinity;
      if (arg0 === -Infinity) {
        num9 = 1;
        return 1;
      } else {
        self = this;
        tmp4 = parseValue;
        iter = parseValue(arg0);
        value = this.value;
        value1 = iter.value;
        if (this.sign !== iter.sign) {
          num8 = -1;
          if (iter.sign) {
            num8 = 1;
          }
          result = num8;
        } else if (iter.isSmall) {
          num7 = 1;
          if (self.sign) {
            num7 = -1;
          }
          result = num7;
        } else {
          if (value.length !== value1.length) {
            num5 = -1;
            if (value.length > value1.length) {
              num5 = 1;
            }
            num3 = num5;
          } else {
            num = 1;
            diff = value.length - 1;
            num2 = 0;
            num3 = 0;
            if (0 <= diff) {
              tmp2 = diff;
              while (value[diff] === value1[diff]) {
                diff = diff - 1;
                num3 = 0;
              }
              num4 = -1;
              if (value[diff] > value1[diff]) {
                num4 = 1;
              }
              num3 = num4;
            }
          }
          num6 = 1;
          if (self.sign) {
            num6 = -1;
          }
          result = num3 * num6;
        }
        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) {
    obj = parseValue(arg0);
    isZeroResult = obj.isZero();
    tmp2 = !isZeroResult;
    if (!isZeroResult) {
      tmp3 = obj.isUnit();
      if (tmp3) {
        tmp2 = tmp3;
      } else {
        self = this;
        num = 2;
        num2 = 0;
        if (0 === require("module_2")) {
          isEvenResult = self.isEven();
        } else {
          modResult = self.mod(obj);
          isEvenResult = modResult.isZero();
        }
        tmp5 = isEvenResult;
      }
    }
    return tmp2;
  }
  isPrime(arg0) {
    self = this;
    absResult = this.abs();
    isUnitResult = absResult.isUnit();
    tmp2 = !isUnitResult;
    if (!isUnitResult) {
      num = 2;
      equalsResult = require("module_2");
      if (!equalsResult) {
        num2 = 3;
        equalsResult = require("module_3");
      }
      if (!equalsResult) {
        num3 = 5;
        equalsResult = require("module_5");
      }
      tmp4 = equalsResult;
      if (!tmp4) {
        isEvenResult = absResult.isEven();
        if (!isEvenResult) {
          num4 = 3;
          isEvenResult = require("module_3");
        }
        if (!isEvenResult) {
          num5 = 5;
          isEvenResult = require("module_5");
        }
        tmp6 = !isEvenResult;
        if (!isEvenResult) {
          num6 = 49;
          tmp7 = require("module_49") || undefined;
          tmp6 = tmp7;
        }
        tmp4 = tmp6;
      }
      tmp2 = tmp4;
    }
    if (tmp2 !== undefined) {
      return tmp2;
    } else {
      absResult1 = self.abs();
      bitLengthResult = absResult1.bitLength();
      num11 = 64;
      if (bitLengthResult <= 64) {
        tmp13 = millerRabinTest;
        num10 = 0;
        return millerRabinTest(absResult1, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
      } else {
        tmp14 = arg0;
        tmp15 = globalThis;
        _Math2 = Math;
        num12 = 2;
        logResult = require("module_2");
        result = logResult * bitLengthResult.toJSNumber();
        flag = true;
        result1 = result;
        if (true === arg0) {
          _Math = Math;
          result1 = 2 * Math.pow(result, 2);
        }
        rounded = Math.ceil(result1);
        items = [];
        num7 = 0;
        num8 = 1;
        for (let num9 = 0; num9 < rounded; num9 = num9 + 1) {
          tmp10 = Integer;
          arr = items.push(Integer(num9 + 2));
        }
        tmp12 = millerRabinTest;
        return millerRabinTest(absResult1, items);
      }
    }
  }
  isProbablePrime(arg0, arg1) {
    self = this;
    absResult = this.abs();
    isUnitResult = absResult.isUnit();
    tmp2 = !isUnitResult;
    if (!isUnitResult) {
      num = 2;
      equalsResult = require("module_2");
      if (!equalsResult) {
        num2 = 3;
        equalsResult = require("module_3");
      }
      if (!equalsResult) {
        num3 = 5;
        equalsResult = require("module_5");
      }
      tmp4 = equalsResult;
      if (!tmp4) {
        isEvenResult = absResult.isEven();
        if (!isEvenResult) {
          num4 = 3;
          isEvenResult = require("module_3");
        }
        if (!isEvenResult) {
          num5 = 5;
          isEvenResult = require("module_5");
        }
        tmp6 = !isEvenResult;
        if (!isEvenResult) {
          num6 = 49;
          tmp7 = require("module_49") || undefined;
          tmp6 = tmp7;
        }
        tmp4 = tmp6;
      }
      tmp2 = tmp4;
    }
    if (tmp2 !== undefined) {
      return tmp2;
    } else {
      tmp8 = arg0;
      absResult1 = self.abs();
      num7 = 5;
      if (arg0 !== undefined) {
        num7 = arg0;
      }
      items = [];
      num8 = 0;
      num9 = 2;
      num10 = 1;
      for (let num11 = 0; num11 < num7; num11 = num11 + 1) {
        tmp9 = Integer;
        arr = items.push(require("module_2"));
      }
      tmp11 = millerRabinTest;
      return millerRabinTest(absResult1, items);
    }
  }
  modInv(arg0) {
    self = this;
    ({ zero, one } = Integer);
    obj = parseValue(arg0);
    absResult = this.abs();
    tmp = absResult;
    obj3 = zero;
    obj4 = obj;
    obj5 = zero;
    if (!absResult.isZero()) {
      do {
        divideResult = obj.divide(tmp);
        subtractResult = obj3.subtract(divideResult.multiply(one));
        subtractResult1 = obj.subtract(divideResult.multiply(tmp));
        obj = tmp;
        obj3 = one;
        tmp = subtractResult1;
        one = subtractResult;
        obj4 = obj;
        obj5 = obj3;
        isZeroResult = subtractResult1.isZero();
      } while (!isZeroResult);
    }
    if (obj4.isUnit()) {
      num = 0;
      num2 = -1;
      addResult = obj5;
      if (-1 === require("module_0")) {
        addResult = obj5.add(arg0);
      }
      negateResult = addResult;
      if (self.isNegative()) {
        negateResult = addResult.negate();
      }
      return negateResult;
    } else {
      tmp4 = globalThis;
      _Error = Error;
      str = " and ";
      text = `${self.toString()} and `;
      tmp6 = new.target;
      str2 = " are not co-prime";
      tmp7 = new.target;
      error = new Error(`${self.toString()} and ` + arg0.toString() + " are not co-prime");
      tmp9 = error;
      throw error;
    }
  }
  next() {
    self = this;
    value = this.value;
    if (this.sign) {
      tmp12 = subtractSmall;
      num8 = 1;
      num9 = 0;
      obj = subtractSmall(value, 1, self.sign);
    } else {
      length = value.length;
      tmp2 = globalThis;
      _Array = Array;
      tmp3 = new.target;
      tmp4 = new.target;
      tmp5 = length;
      tmp = BigInteger;
      array = new Array(length);
      tmp7 = array;
      num = 0;
      num2 = 1;
      num3 = 10000000;
      num4 = 0;
      num5 = 1;
      num6 = 0;
      num7 = 1;
      if (0 < length) {
        do {
          sum = value[num4] - 10000000 + num5;
          _Math = Math;
          rounded = Math.floor(sum / 10000000);
          array[num4] = sum - rounded * 10000000;
          num5 = rounded + 1;
          num4 = num4 + 1;
          num7 = num5;
          num6 = num4;
        } while (num4 < length);
      }
      if (num7 > 0) {
        do {
          array[num6] = num7 % 10000000;
          _Math2 = Math;
          sum1 = num6 + 1;
          num7 = Math.floor(num7 / 10000000);
          num6 = sum1;
        } while (num7 > 0);
      }
      obj = Object.create(tmp.prototype);
      obj = {};
      obj.value = array;
      obj.sign = self.sign;
      flag = false;
      obj.isSmall = false;
    }
    return obj;
  }
  prev() {
    value = this.value;
    if (this.sign) {
      length = value.length;
      tmp5 = globalThis;
      _Array = Array;
      tmp6 = new.target;
      tmp7 = new.target;
      tmp8 = length;
      tmp4 = BigInteger;
      array = new Array(length);
      tmp10 = array;
      num3 = 0;
      num4 = 1;
      num5 = 10000000;
      num6 = 0;
      num7 = 1;
      num8 = 0;
      num9 = 1;
      if (0 < length) {
        do {
          sum = value[num6] - 10000000 + num7;
          _Math = Math;
          rounded = Math.floor(sum / 10000000);
          array[num6] = sum - rounded * 10000000;
          num7 = rounded + 1;
          num6 = num6 + 1;
          num9 = num7;
          num8 = num6;
        } while (num6 < length);
      }
      if (num9 > 0) {
        do {
          array[num8] = num9 % 10000000;
          _Math2 = Math;
          sum1 = num8 + 1;
          num9 = Math.floor(num9 / 10000000);
          num8 = sum1;
        } while (num9 > 0);
      }
      obj = Object.create(tmp4.prototype);
      obj = {};
      obj.value = array;
      flag = true;
      obj.sign = true;
      flag2 = false;
      obj.isSmall = false;
      tmp3 = obj;
    } else {
      tmp2 = subtractSmall;
      num = 1;
      num2 = 0;
      tmp3 = subtractSmall(value, 1, tmp.sign);
    }
    return tmp3;
  }
  shiftLeft(arg0) {
    obj = parseValue(arg0);
    toJSNumberResult = obj.toJSNumber();
    if (Math.abs(toJSNumberResult) <= 10000000) {
      self = this;
      num = 0;
      if (toJSNumberResult < 0) {
        return self.shiftRight(-toJSNumberResult);
      } else if (self.isZero()) {
        return self;
      } else {
        tmp6 = length;
        num2 = 1;
        multiplyResult = self;
        diff = toJSNumberResult;
        obj3 = self;
        tmp8 = toJSNumberResult;
        if (toJSNumberResult >= length) {
          do {
            tmp9 = f65967;
            multiplyResult = multiplyResult.multiply(f65967);
            tmp10 = length;
            diff = diff - (length - 1);
            obj3 = multiplyResult;
            tmp8 = diff;
          } while (diff >= length);
        }
        tmp11 = f65967;
        return obj3.multiply(f65967[tmp8]);
      }
    } else {
      _Error = Error;
      _String = String;
      str = " is too large for shifting.";
      tmp2 = new.target;
      tmp3 = new.target;
      error = new Error(String(toJSNumberResult) + " is too large for shifting.");
      tmp5 = error;
      throw error;
    }
  }
  shiftRight(arg0) {
    obj = parseValue(arg0);
    toJSNumberResult = obj.toJSNumber();
    if (Math.abs(toJSNumberResult) <= 10000000) {
      self = this;
      num = 0;
      if (toJSNumberResult < 0) {
        return self.shiftLeft(-toJSNumberResult);
      } else {
        tmp20 = length;
        num2 = 1;
        obj4 = self;
        diff = toJSNumberResult;
        tmp14 = self;
        tmp15 = toJSNumberResult;
        if (toJSNumberResult >= length) {
          tmp6 = obj4;
          tmp7 = diff;
          while (!obj4.isZero()) {
            if (!obj4.isNegative()) {
              tmp8 = divModAny;
              tmp9 = f65967;
              tmp10 = divModAny(obj4, f65967);
              [obj3, obj2] = tmp10;
              if (obj2.isNegative()) {
                prevResult = obj3.prev();
              } else {
                prevResult = obj3;
              }
              tmp12 = length;
              diff = diff - (length - 1);
              obj4 = prevResult;
              tmp14 = prevResult;
              tmp15 = diff;
            } else if (obj4.isUnit()) {
              break;
            }
            return obj4;
          }
        }
        tmp16 = divModAny;
        tmp17 = f65967;
        tmp18 = divModAny(tmp14, f65967[tmp15]);
        [obj6, obj5] = tmp18;
        if (obj5.isNegative()) {
          prevResult1 = obj6.prev();
        } else {
          prevResult1 = obj6;
        }
        return prevResult1;
      }
    } else {
      _Error = Error;
      _String = String;
      str = " is too large for shifting.";
      tmp2 = new.target;
      tmp3 = new.target;
      error = new Error(String(toJSNumberResult) + " is too large for shifting.");
      tmp5 = 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;
    tmp = Integer;
    self2 = this;
    if (this.compareTo(require("module_0")) < 0) {
      negateResult = self.negate();
      num = 1;
      self2 = negateResult.subtract(require("module_1"));
    }
    if (0 === self2.compareTo(require("module_0"))) {
      tmpResult = require("module_0");
    } else {
      num6 = 2;
      tmpResult1 = require("module_2");
      if (tmpResult1.compareTo(self2) <= 0) {
        squareResult = tmpResult1.square(tmpResult1);
        if (squareResult.compareTo(self2) <= 0) {
          tmp2 = integerLogarithm;
          tmp3 = integerLogarithm(self2, squareResult.square(squareResult));
          ({ p, e } = tmp3);
          multiplyResult = p.multiply(squareResult);
          if (multiplyResult.compareTo(self2) <= 0) {
            obj = { p: null, e: null };
            obj[0] = multiplyResult;
            num4 = 1;
            obj[1] = num6 * e + 1;
            obj1 = obj;
          } else {
            obj1 = { p: null, e: null };
            obj1[0] = p;
            obj1[1] = num6 * e;
          }
          tmp4 = obj1;
        } else {
          obj2 = { p: null, e: 0 };
          num3 = 1;
          obj2[0] = require("module_1");
          ({ p: p2, e: e2 } = obj2);
          multiplyResult1 = p2.multiply(tmpResult1);
          if (multiplyResult1.compareTo(self2) <= 0) {
            obj3 = { p: null, e: null };
            obj3[0] = multiplyResult1;
            num5 = 1;
            num6 = num6 * e2 + 1;
            obj3[1] = num6;
            obj4 = obj3;
          } else {
            obj4 = { p: null, e: null };
            obj4[0] = p2;
            obj4[1] = num6 * e2;
          }
          tmp5 = obj4;
        }
      } else {
        obj5 = { p: null, e: 0 };
        num2 = 1;
        obj5[0] = require("module_1");
        tmpResult2 = tmp(obj5.e);
        num7 = 1;
        tmpResult = tmpResult2.add(require("module_1"));
      }
    }
    return tmpResult;
  }
  toArray(arg0) {
    return toBase(this, arg0);
  }
  toString(arg0, arg1) {
    num = arg0;
    if (arg0 === undefined) {
      num = 10;
    }
    self = this;
    if (10 !== num) {
      tmp4 = arg1;
      closure_0 = arg1;
      tmp5 = toBase;
      num2 = 0;
      iter = toBase(self, num);
      str2 = "";
      str3 = "";
      if (iter.isNegative) {
        str3 = "-";
      }
      value = iter.value;
      mapped = value.map((arg0) => {
        let arr = closure_0;
        if (!closure_0) {
          arr = outer1_1;
        }
        if (arg0 < arr.length) {
          let text = arr[arg0];
        } else {
          text = `${"<" + arg0}>`;
        }
        return text;
      });
      return str3 + mapped.join("");
    } else {
      value1 = self.value;
      tmp6 = globalThis;
      _String2 = String;
      diff = value1.length - 1;
      StringResult = String(value1[diff]);
      diff1 = diff - 1;
      num3 = 0;
      str4 = "0000000";
      sum = StringResult;
      tmp3 = StringResult;
      if (diff1 >= 0) {
        do {
          _String = String;
          StringResult1 = String(value1[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) {
    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;
      tmp24 = value;
      if (!iter.isSmall) {
        tmp7 = globalThis;
        _Math5 = Math;
        tmp6 = BigInteger;
        absolute = Math.abs(value);
        length = value.length;
        _Array = Array;
        tmp9 = new.target;
        tmp10 = new.target;
        tmp11 = length;
        array = new Array(length);
        tmp13 = array;
        num4 = 10000000;
        num5 = 1;
        num6 = 0;
        sum1 = absolute;
        num7 = 0;
        rounded1 = absolute;
        if (0 < length) {
          do {
            sum = value[num6] - 10000000 + sum1;
            _Math6 = Math;
            rounded = Math.floor(sum / 10000000);
            array[num6] = sum - rounded * 10000000;
            sum1 = rounded + 1;
            num6 = num6 + 1;
            rounded1 = sum1;
            num7 = num6;
          } while (num6 < length);
        }
        if (rounded1 > 0) {
          do {
            array[num7] = rounded1 % 10000000;
            _Math7 = Math;
            sum2 = num7 + 1;
            rounded1 = Math.floor(rounded1 / 10000000);
            num7 = sum2;
          } while (rounded1 > 0);
        }
        tmp19 = value < 0;
        obj = Object.create(tmp6.prototype);
        obj = {};
        obj.value = array;
        obj.sign = tmp19;
        flag = false;
        obj.isSmall = false;
        return obj;
      } else {
        sum3 = value + value;
        num = -9007199254740992;
        tmp2 = -9007199254740992 < sum3;
        if (tmp2) {
          num2 = 9007199254740992;
          tmp2 = sum3 < 9007199254740992;
        }
        if (tmp2) {
          tmp21 = SmallInteger;
          sum4 = value + value;
          obj1 = Object.create(SmallInteger.prototype);
          obj2 = {};
          obj2.value = sum4;
          obj2.sign = sum4 < 0;
          flag2 = true;
          obj2.isSmall = true;
          return obj2;
        } else {
          tmp3 = globalThis;
          _Math = Math;
          absolute1 = Math.abs(value);
          num3 = 10000000;
          if (absolute1 < 10000000) {
            items = [];
            items[0] = absolute1;
            items2 = items;
          } else {
            num8 = 100000000000000;
            if (absolute1 < 100000000000000) {
              items1 = [, ];
              items1[0] = absolute1 % 10000000;
              _Math4 = Math;
              items1[1] = Math.floor(absolute1 / 10000000);
              items2 = items1;
            } else {
              items2 = [, , ];
              items2[0] = absolute1 % 10000000;
              _Math2 = Math;
              items2[1] = Math.floor(absolute1 / 10000000) % 10000000;
              _Math3 = Math;
              items2[2] = Math.floor(absolute1 / 100000000000000);
            }
          }
          tmp5 = items2;
        }
      }
    }
    return;
  }
  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;
        diff = value - value;
        obj = Object.create(SmallInteger.prototype);
        obj = {};
        obj.value = diff;
        obj.sign = diff < 0;
        flag = true;
        obj.isSmall = true;
        tmp3 = obj;
      } else {
        tmp = subtractSmall;
        tmp2 = globalThis;
        _Math = Math;
        tmp3 = subtractSmall(value, Math.abs(value), value >= 0);
      }
      return tmp3;
    }
  }
  negate() {
    tmp = -this.value;
    obj = Object.create(SmallInteger.prototype);
    obj = { value: tmp, sign: tmp < 0, isSmall: true, sign: !this.sign };
    return obj;
  }
  abs() {
    absolute = Math.abs(this.value);
    obj = Object.create(SmallInteger.prototype);
    obj = { value: absolute, sign: absolute < 0, isSmall: true };
    return obj;
  }
  _multiplyBySmall(arg0) {
    self = this;
    result = arg0.value * this.value;
    tmp2 = -9007199254740992 < result;
    if (tmp2) {
      num = 9007199254740992;
      tmp2 = result < 9007199254740992;
    }
    if (tmp2) {
      tmp8 = SmallInteger;
      result1 = arg0.value * self.value;
      obj = Object.create(SmallInteger.prototype);
      obj = {};
      obj.value = result1;
      num4 = 0;
      obj.sign = result1 < 0;
      flag = true;
      obj.isSmall = true;
      tmp3Result = obj;
    } else {
      tmp4 = globalThis;
      _Math = Math;
      tmp3 = multiplySmallAndArray;
      _Math2 = Math;
      absolute = Math.abs(arg0.value);
      absolute1 = Math.abs(self.value);
      num2 = 10000000;
      if (absolute1 < 10000000) {
        items = [];
        items[0] = absolute1;
        items2 = items;
      } else {
        num5 = 100000000000000;
        if (absolute1 < 100000000000000) {
          items1 = [, ];
          items1[0] = absolute1 % 10000000;
          _Math5 = Math;
          items1[1] = Math.floor(absolute1 / 10000000);
          items2 = items1;
        } else {
          items2 = [, , ];
          items2[0] = absolute1 % 10000000;
          _Math3 = Math;
          items2[1] = Math.floor(absolute1 / 10000000) % 10000000;
          _Math4 = Math;
          items2[2] = Math.floor(absolute1 / 100000000000000);
        }
      }
      num3 = 0;
      tmp3Result = tmp3(absolute, items2, self.sign !== arg0.sign);
    }
    return tmp3Result;
  }
  multiply(arg0) {
    obj = parseValue(arg0);
    return obj._multiplyBySmall(this);
  }
  square() {
    result = this.value * this.value;
    tmp2 = -9007199254740992 < result;
    if (tmp2) {
      num = 9007199254740992;
      tmp2 = result < 9007199254740992;
    }
    if (tmp2) {
      tmp9 = SmallInteger;
      obj = Object.create(SmallInteger.prototype);
      obj1 = {};
      obj1.value = result;
      num4 = 0;
      obj1.sign = result < 0;
      flag2 = true;
      obj1.isSmall = true;
      obj = obj1;
    } else {
      tmp5 = globalThis;
      _Math = Math;
      tmp3 = BigInteger;
      tmp4 = square;
      absolute = Math.abs(this.value);
      num2 = 10000000;
      if (absolute < 10000000) {
        items = [];
        items[0] = absolute;
        items2 = items;
      } else {
        num5 = 100000000000000;
        if (absolute < 100000000000000) {
          items1 = [, ];
          items1[0] = absolute % 10000000;
          _Math4 = Math;
          items1[1] = Math.floor(absolute / 10000000);
          items2 = items1;
        } else {
          items2 = [, , ];
          items2[0] = absolute % 10000000;
          _Math2 = Math;
          items2[1] = Math.floor(absolute / 10000000) % 10000000;
          _Math3 = Math;
          items2[2] = Math.floor(absolute / 100000000000000);
        }
      }
      num3 = 0;
      tmp4Result = tmp4(items2);
      obj2 = Object.create(tmp3.prototype);
      obj = {};
      obj.value = tmp4Result;
      flag = false;
      obj.sign = false;
      obj.isSmall = false;
    }
    return obj;
  }
  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 {
        self = this;
        tmp = parseValue;
        iter = parseValue(arg0);
        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) {
      tmp4 = SmallInteger;
      sum = value + 1;
      obj = Object.create(SmallInteger.prototype);
      obj1 = {};
      obj1.value = sum;
      num = 0;
      obj1.sign = sum < 0;
      flag2 = true;
      obj1.isSmall = true;
      obj = obj1;
    } else {
      tmp = BigInteger;
      tmp2 = Integer;
      obj2 = Object.create(BigInteger.prototype);
      obj = {};
      obj.value = Integer;
      flag = false;
      obj.sign = false;
      obj.isSmall = false;
    }
    return obj;
  }
  prev() {
    value = this.value;
    if (-9007199254740992 < value - 1) {
      tmp4 = SmallInteger;
      diff = value - 1;
      obj = Object.create(SmallInteger.prototype);
      obj1 = {};
      obj1.value = diff;
      num = 0;
      obj1.sign = diff < 0;
      flag3 = true;
      obj1.isSmall = true;
      obj = obj1;
    } else {
      tmp = BigInteger;
      tmp2 = Integer;
      obj2 = Object.create(BigInteger.prototype);
      obj = {};
      obj.value = Integer;
      flag = true;
      obj.sign = true;
      flag2 = false;
      obj.isSmall = false;
    }
    return obj;
  }
  toArray(arg0) {
    return toBase(this, arg0);
  }
  toString(arg0, arg1) {
    num = arg0;
    if (arg0 === undefined) {
      num = 10;
    }
    self = this;
    if (10 != num) {
      tmp3 = arg1;
      closure_0 = arg1;
      tmp4 = toBase;
      num2 = 0;
      iter = toBase(self, num);
      str = "";
      str2 = "";
      if (iter.isNegative) {
        str2 = "-";
      }
      value = iter.value;
      mapped = value.map((arg0) => {
        let arr = closure_0;
        if (!closure_0) {
          arr = outer1_1;
        }
        if (arg0 < arr.length) {
          let text = arr[arg0];
        } else {
          text = `${"<" + arg0}>`;
        }
        return text;
      });
      sum = str2 + mapped.join("");
    } else {
      tmp = globalThis;
      _String = String;
      sum = String(self.value);
    }
    return sum;
  }
  valueOf() {
    return this.value;
  }
}
class NativeBigInt {
  constructor(arg0) {
    this.value = arg0;
    return;
  }
  add(arg0) {
    sum = this.value + parseValue(arg0).value;
    obj = Object.create(NativeBigInt.prototype);
    obj.value = sum;
    return obj;
  }
  subtract(arg0) {
    diff = this.value - parseValue(arg0).value;
    obj = Object.create(NativeBigInt.prototype);
    obj.value = diff;
    return obj;
  }
  negate() {
    tmp = -this.value;
    obj = Object.create(NativeBigInt.prototype);
    obj.value = tmp;
    return obj;
  }
  abs() {
    self = this;
    tmp = NativeBigInt;
    if (this.value >= 0) {
      value = self.value;
    } else {
      value = -self.value;
    }
    obj = Object.create(tmp.prototype);
    obj.value = value;
    return obj;
  }
  multiply(arg0) {
    result = this.value * parseValue(arg0).value;
    obj = Object.create(NativeBigInt.prototype);
    obj.value = result;
    return obj;
  }
  square(arg0) {
    result = this.value * this.value;
    obj = Object.create(NativeBigInt.prototype);
    obj.value = result;
    return obj;
  }
  pow(arg0) {
    self = this;
    iter = parseValue(arg0);
    value = this.value;
    value = iter.value;
    BigIntResult = require("module_0");
    BigIntResult1 = require("module_1");
    if (value === BigIntResult) {
      tmp18 = Integer;
      return Integer[1];
    } else if (value === BigIntResult) {
      tmp17 = Integer;
      return Integer[0];
    } else if (value === BigIntResult1) {
      tmp16 = Integer;
      return Integer[1];
    } else {
      _BigInt = BigInt;
      num = -1;
      if (value === require("module_4294967295")) {
        tmp15 = Integer;
        return iter.isEven() ? tmp15[1] : tmp15[-1];
      } else if (iter.isNegative()) {
        tmp13 = NativeBigInt;
        obj = Object.create(NativeBigInt.prototype);
        obj.value = BigIntResult;
        return obj;
      } else {
        tmp4 = Integer;
        obj = Integer[1];
        timesResult = obj;
        diff = value;
        if ((value & BigIntResult1) === BigIntResult1) {
          timesResult = obj.times(self);
          diff = value - 1;
        }
        obj2 = timesResult;
        tmp7 = timesResult;
        if (diff !== BigIntResult) {
          do {
            result = diff / tmp3;
            squareResult = self.square();
            tmp10 = obj2;
            timesResult1 = obj2;
            diff1 = result;
            if ((result & BigIntResult1) === BigIntResult1) {
              timesResult1 = obj2.times(squareResult);
              diff1 = result - 1;
            }
            obj2 = timesResult1;
            diff = diff1;
            self = squareResult;
            tmp7 = timesResult1;
          } while (diff1 !== 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 & require("module_1");
    return tmp === require("module_0");
  }
  isOdd() {
    tmp = this.value & require("module_1");
    return tmp === require("module_1");
  }
  isUnit() {
    return this.abs().value === require("module_1");
  }
  isZero() {
    return this.value === require("module_0");
  }
  next() {
    sum = this.value + require("module_1");
    obj = Object.create(NativeBigInt.prototype);
    obj.value = sum;
    return obj;
  }
  prev() {
    diff = this.value - require("module_1");
    obj = Object.create(NativeBigInt.prototype);
    obj.value = diff;
    return obj;
  }
  toArray(arg0) {
    return toBase(this, arg0);
  }
}
function arrayToSmall(array) {
  let tmp5;
  const diff = array.length - 1;
  let tmp2 = diff;
  let tmp3 = diff;
  if (0 === array[diff]) {
    do {
      let diff1 = tmp2 - 1;
      tmp2 = diff1;
      tmp3 = diff1;
      tmp5 = array[diff1];
    } while (0 === tmp5);
  }
  array.length = tmp3 + 1;
  if (array.length < 4) {
    if (array.length !== Integer.length) {
      let num3 = -1;
      if (array.length > arr.length) {
        num3 = 1;
      }
      let num = num3;
    } else {
      let diff2 = array.length - 1;
      num = 0;
      if (0 <= diff2) {
        while (array[diff2] === arr[diff2]) {
          diff2 = diff2 - 1;
          num = 0;
        }
        let num2 = -1;
        if (array[diff2] > arr[diff2]) {
          num2 = 1;
        }
        num = num2;
      }
    }
    if (num < 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 addAny(substr1, substr) {
  if (substr1.length >= substr.length) {
    const _Array = Array;
    let arr = new Array(length);
    let num10 = 0;
    let num11 = 0;
    let num12 = 0;
    let num13 = 0;
    if (0 < substr.length) {
      do {
        let sum = substr1[num11] + substr[num11] + num10;
        let tmp14 = num11;
        let num14 = 0;
        if (sum >= 10000000) {
          num14 = 1;
        }
        arr[num11] = sum - num14 * 10000000;
        num11 = num11 + 1;
        num10 = num14;
        num12 = num14;
        num13 = num11;
      } while (num11 < length2);
    }
    let tmp15 = num12;
    let tmp16 = num12;
    if (num13 < substr1.length) {
      do {
        let sum1 = substr1[num13] + tmp15;
        let num15 = 0;
        let tmp18 = num13;
        if (sum1 === 10000000) {
          num15 = 1;
        }
        num13 = num13 + 1;
        arr[tmp18] = sum1 - num15 * 10000000;
        tmp15 = num15;
        tmp16 = num15;
      } while (num13 < length);
    }
    let tmp7 = arr;
    if (0 < tmp16) {
      arr = arr.push(tmp16);
      tmp7 = arr;
    }
  } else {
    const _Array2 = Array;
    const array = new Array(length3);
    let num3 = 0;
    let num2 = 0;
    let num4 = 0;
    let num5 = 0;
    if (0 < substr1.length) {
      do {
        let sum2 = substr[num2] + substr1[num2] + num3;
        let tmp2 = num2;
        let num = 0;
        if (sum2 >= 10000000) {
          num = 1;
        }
        array[num2] = sum2 - num * 10000000;
        num2 = num2 + 1;
        num3 = num;
        num4 = num;
        num5 = num2;
      } while (num2 < length4);
    }
    let tmp3 = num4;
    let tmp4 = num4;
    if (num5 < substr.length) {
      do {
        let sum3 = substr[num5] + tmp3;
        let num6 = 0;
        let tmp6 = num5;
        if (sum3 === 10000000) {
          num6 = 1;
        }
        num5 = num5 + 1;
        array[tmp6] = sum3 - num6 * 10000000;
        tmp3 = num6;
        tmp4 = num6;
      } while (num5 < length3);
    }
    tmp7 = array;
    if (0 < tmp4) {
      arr = array.push(tmp4);
      tmp7 = array;
    }
  }
  return tmp7;
}
function subtract(arg0, arg1) {
  let tmp13;
  const arr = new Array(arg0.length);
  let num = 0;
  let num2 = 0;
  let num3 = 0;
  if (0 < arg1.length) {
    do {
      let diff = arg0[num2] - num - arg1[num2];
      let tmp2 = num2;
      let num4 = 0;
      let sum = diff;
      if (diff < 0) {
        sum = diff + 10000000;
        num4 = 1;
      }
      arr[num2] = sum;
      num2 = num2 + 1;
      num = num4;
      num3 = num4;
    } while (num2 < length2);
  }
  let sum1 = length2;
  let sum2 = length2;
  if (arg1.length < arg0.length) {
    const diff1 = arg0[sum1] - num3;
    while (diff1 < 0) {
      arr[sum1] = diff1 + 10000000;
      sum1 = sum1 + 1;
      sum2 = sum1;
    }
    sum2 = tmp8 + 1;
    arr[+sum1] = diff1;
  }
  if (sum2 < arg0.length) {
    do {
      arr[sum2] = arg0[sum2];
      sum2 = sum2 + 1;
    } while (sum2 < length);
  }
  const diff2 = arr.length - 1;
  let tmp10 = diff2;
  let tmp11 = diff2;
  if (0 === arr[diff2]) {
    do {
      let diff3 = tmp10 - 1;
      tmp10 = diff3;
      tmp11 = diff3;
      tmp13 = arr[diff3];
    } while (0 === tmp13);
  }
  arr.length = tmp11 + 1;
  return arr;
}
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 tmp6 = num;
      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 tmp8 = arrayToSmall(array);
  if (typeof tmp8 === "number") {
    let tmp9 = tmp8;
    if (sign) {
      tmp9 = -tmp8;
    }
    let obj = Object.create(SmallInteger.prototype);
    obj = { value: tmp9, sign: tmp9 < 0, isSmall: true };
    let obj1 = obj;
  } else {
    obj = Object.create(BigInteger.prototype);
    obj1 = { value: tmp8, sign, isSmall: false };
  }
  return obj1;
}
function multiplyLong(value, value2) {
  let tmp12;
  const sum = length + length2;
  const arr = new Array(sum);
  let num = 0;
  if (0 < sum) {
    do {
      arr[num] = 0;
      num = num + 1;
    } while (num < sum);
  }
  for (let num2 = 0; num2 < length; num2 = num2 + 1) {
    let tmp3 = num2;
    for (let num3 = 0; num3 < length2; num3 = num3 + 1) {
      let sum1 = num2 + num3;
      let sum2 = tmp2 * value2[num3] + arr[sum1];
      let _Math = Math;
      let rounded = Math.floor(sum2 / 10000000);
      arr[sum1] = sum2 - rounded * 10000000;
      let sum3 = sum1 + 1;
      arr[sum3] = arr[sum3] + rounded;
    }
  }
  const diff = arr.length - 1;
  let tmp9 = diff;
  let tmp10 = diff;
  if (0 === arr[diff]) {
    do {
      let diff1 = tmp9 - 1;
      tmp9 = diff1;
      tmp10 = diff1;
      tmp12 = arr[diff1];
    } while (0 === tmp12);
  }
  arr.length = tmp10 + 1;
  return arr;
}
function multiplyKaratsuba(substr, substr2) {
  let tmp14;
  let tmp3;
  let tmp9;
  const bound = Math.max(substr.length, substr2.length);
  if (bound <= 30) {
    return multiplyLong(substr, substr2);
  } else {
    const _Math = Math;
    const rounded = Math.ceil(bound / 2);
    substr = substr.slice(rounded);
    const substr1 = substr.slice(0, rounded);
    substr2 = substr2.slice(rounded);
    const substr3 = substr2.slice(0, rounded);
    const tmp22 = multiplyKaratsuba(substr1, substr3);
    const tmp23 = multiplyKaratsuba(substr, substr2);
    const items = [];
    let diff = tmp28 - 1;
    const tmp25 = addAny(substr1, substr);
    if (+rounded > 0) {
      do {
        let arr = items.push(0);
        tmp3 = +diff;
        diff = tmp3 - 1;
      } while (tmp3 > 0);
    }
    const result = 2 * rounded;
    const items1 = [];
    let diff1 = result - 1;
    let tmp24Result = tmp24(tmp22, items.concat(subtract(subtract(multiplyKaratsuba(addAny(substr1, substr), addAny(substr3, substr2)), tmp22), tmp23)));
    if (0 < result) {
      do {
        arr = items1.push(0);
        tmp9 = diff1;
        diff1 = diff1 - 1;
      } while (0 < tmp9);
    }
    tmp24Result = tmp24(tmp24Result, items1.concat(tmp23));
    const diff2 = tmp24Result.length - 1;
    let tmp11 = diff2;
    let tmp12 = diff2;
    if (0 === tmp24Result[diff2]) {
      do {
        let diff3 = tmp11 - 1;
        tmp11 = diff3;
        tmp12 = diff3;
        tmp14 = tmp24Result[diff3];
      } while (0 === tmp14);
    }
    tmp24Result.length = tmp12 + 1;
    return tmp24Result;
  }
}
function multiplySmallAndArray(arg0, value, sign) {
  if (arg0 < 10000000) {
    const _Array = Array;
    const array = new Array(length);
    let num4 = 0;
    let num5 = 0;
    let num6 = 0;
    let num7 = 0;
    if (0 < value.length) {
      do {
        let sum = value[num5] * arg0 + num4;
        let _Math4 = Math;
        let rounded = Math.floor(sum / 10000000);
        array[num5] = sum - rounded * 10000000;
        num5 = num5 + 1;
        num4 = rounded;
        num6 = rounded;
        num7 = num5;
      } while (num5 < length);
    }
    let tmp15Result = array;
    if (num6 > 0) {
      do {
        array[num7] = num6 % 10000000;
        let _Math5 = Math;
        let sum1 = num7 + 1;
        num6 = Math.floor(num6 / 10000000);
        num7 = sum1;
        tmp15Result = array;
      } while (num6 > 0);
    }
  } else {
    if (arg0 < 10000000) {
      const items = [arg0];
      let items2 = items;
    } else if (arg0 < 100000000000000) {
      const items1 = [arg0 % 10000000, ];
      const _Math3 = Math;
      items1[1] = Math.floor(arg0 / 10000000);
      items2 = items1;
    } else {
      items2 = [arg0 % 10000000, , ];
      const _Math = Math;
      items2[1] = Math.floor(arg0 / 10000000) % 10000000;
      const _Math2 = Math;
      items2[2] = Math.floor(arg0 / 100000000000000);
    }
    tmp15Result = multiplyLong(value, items2);
    const tmp15 = multiplyLong;
  }
  let obj = Object.create(BigInteger.prototype);
  obj = { value: tmp15Result, sign, isSmall: false };
  return obj;
}
function square(squareResult) {
  let tmp14;
  const sum = length + length;
  const arr = new Array(sum);
  let num = 0;
  if (0 < sum) {
    do {
      arr[num] = 0;
      num = num + 1;
    } while (num < sum);
  }
  for (let num2 = 0; num2 < length; num2 = num2 + 1) {
    let tmp2 = squareResult[num2];
    let diff = 0 - tmp2 * tmp2;
    let tmp4 = num2;
    let tmp5 = diff;
    let sum3 = num2;
    if (num2 < length) {
      do {
        let sum1 = num2 + sum3;
        let sum2 = tmp2 * squareResult[sum3] * 2 + arr[sum1] + diff;
        let _Math = Math;
        let rounded = Math.floor(sum2 / 10000000);
        arr[sum1] = sum2 - rounded * 10000000;
        sum3 = sum3 + 1;
        diff = rounded;
        tmp5 = rounded;
      } while (sum3 < length);
    }
    arr[num2 + length] = tmp5;
  }
  const diff1 = arr.length - 1;
  let tmp11 = diff1;
  let tmp12 = diff1;
  if (0 === arr[diff1]) {
    do {
      let diff2 = tmp11 - 1;
      tmp11 = diff2;
      tmp12 = diff2;
      tmp14 = arr[diff2];
    } while (0 === tmp14);
  }
  arr.length = tmp12 + 1;
  return arr;
}
function divModAny(value, closure_19) {
  let diff4;
  let length4;
  let length5;
  const iter = parseValue(closure_19);
  if (closure_2) {
    let result = NativeBigInt;
    result = value.value / iter.value;
    result = Object.create(NativeBigInt.prototype);
    result.value = result;
    const items = [result, ];
    result = value.value % iter.value;
    result = Object.create(NativeBigInt.prototype);
    result.value = result;
    items[1] = result;
    return items;
  } else {
    result = value.value;
    value = iter.value;
    if (0 === value) {
      result = globalThis;
      const _Error = Error;
      result = new.target;
      result = new.target;
      result = new Error("Cannot divide by zero");
      throw result;
    } else {
      const isSmall = iter.isSmall;
      if (value.isSmall) {
        if (isSmall) {
          result = SmallInteger;
          result = result / value;
          if (result > 0) {
            result = globalThis;
            const _Math19 = Math;
            result = Math.floor(result);
          } else {
            result = globalThis;
            const _Math18 = Math;
            result = Math.ceil(result);
          }
          result = Object.create(result.prototype);
          let obj = { value: result, sign: result < 0, isSmall: true };
          const items1 = [obj, ];
          result = result % value;
          result = Object.create(result.prototype);
          value = { value: result, sign: result < 0, isSmall: true };
          items1[1] = value;
          result = items1;
        } else {
          result = Integer;
          const items2 = [Integer[0], value];
          return items2;
        }
      } else {
        result = value;
        if (!isSmall) {
          if (result.length !== value.length) {
            let num6 = -1;
            if (result.length > value.length) {
              num6 = 1;
            }
            let num4 = num6;
          } else {
            let diff = result.length - 1;
            num4 = 0;
            if (0 <= diff) {
              while (result[diff] === value[diff]) {
                diff = diff - 1;
                num4 = 0;
              }
              let num5 = -1;
              if (result[diff] > value[diff]) {
                num5 = 1;
              }
              num4 = num5;
            }
          }
          let num7 = -1;
          if (-1 === num4) {
            const items3 = [Integer[0], value];
            return items3;
          } else if (0 === num4) {
            if (value.sign === iter.sign) {
              num7 = 1;
            }
            const items4 = [Integer[num7], Integer[0]];
            return items4;
          } else {
            if (result.length + value.length <= 200) {
              ({ length: length4, length: length5 } = value);
              const _Array2 = Array;
              let array = new Array(length5);
              for (let num19 = 0; num19 < length5; num19 = num19 + 1) {
                array[num19] = 0;
              }
              const _Math7 = Math;
              const rounded = Math.ceil(10000000 / (2 * value[length4 - 1]));
              const _Array3 = Array;
              array = new Array(length6);
              let num22 = 0;
              let num23 = 0;
              let num24 = 0;
              let num25 = 0;
              if (0 < result.length) {
                do {
                  let sum = result[num23] * rounded + num22;
                  let _Math8 = Math;
                  let rounded1 = Math.floor(sum / 10000000);
                  array[num23] = sum - rounded1 * 10000000;
                  num23 = num23 + 1;
                  num22 = rounded1;
                  num24 = rounded1;
                  num25 = num23;
                } while (num23 < length6);
              }
              if (num24 > 0) {
                do {
                  array[num25] = num24 % 10000000;
                  let _Math9 = Math;
                  let sum1 = num25 + 1;
                  num24 = Math.floor(num24 / 10000000);
                  num25 = sum1;
                } while (num24 > 0);
              }
              const _Array4 = Array;
              const array1 = new Array(length7);
              let num26 = 0;
              let num27 = 0;
              let num28 = 0;
              let num29 = 0;
              if (0 < value.length) {
                do {
                  let sum2 = value[num27] * rounded + num26;
                  let _Math10 = Math;
                  let rounded2 = Math.floor(sum2 / 10000000);
                  array1[num27] = sum2 - rounded2 * 10000000;
                  num27 = num27 + 1;
                  num26 = rounded2;
                  num28 = rounded2;
                  num29 = num27;
                } while (num27 < length7);
              }
              if (num28 > 0) {
                do {
                  array1[num29] = num28 % 10000000;
                  let _Math11 = Math;
                  let sum3 = num29 + 1;
                  num28 = Math.floor(num28 / 10000000);
                  num29 = sum3;
                } while (num28 > 0);
              }
              if (array.length <= result.length) {
                array.push(0);
              }
              array1.push(0);
              let diff1 = length3 - length4;
              if (diff1 >= 0) {
                do {
                  let tmp60 = diff1;
                  let num31 = 9999999;
                  if (array[diff1 + length4] !== tmp58) {
                    let _Math12 = Math;
                    num31 = Math.floor((array[diff1 + length4] * 10000000 + array[diff1 + length4 - 1]) / tmp58);
                  }
                  let length8 = array1.length;
                  let num32 = 0;
                  let num33 = 0;
                  let num34 = 0;
                  let num35 = 0;
                  if (0 < length8) {
                    do {
                      let sum4 = num34 + num31 * array1[num32];
                      let _Math13 = Math;
                      let rounded3 = Math.floor(sum4 / 10000000);
                      let sum5 = num33 + (array[diff1 + num32] - (sum4 - rounded3 * 10000000));
                      let tmp64 = num32;
                      if (sum5 < 0) {
                        array[diff1 + num32] = sum5 + 10000000;
                        let num36 = num7;
                      } else {
                        array[diff1 + num32] = sum5;
                        num36 = 0;
                      }
                      num32 = num32 + 1;
                      num33 = num36;
                      num34 = rounded3;
                      num35 = num36;
                    } while (num32 < length8);
                  }
                  let tmp65 = num31;
                  let tmp66 = num31;
                  if (0 !== num35) {
                    do {
                      let diff2 = tmp65 - 1;
                      let tmp68 = num35;
                      let num37 = 0;
                      let num38 = 0;
                      let num39 = 0;
                      if (0 < length8) {
                        do {
                          let sum6 = num38 + (array[diff1 + num37] - 10000000 + array1[num37]);
                          let tmp70 = num37;
                          if (sum6 < 0) {
                            array[diff1 + num37] = sum6 + 10000000;
                            let num40 = 0;
                          } else {
                            array[diff1 + num37] = sum6;
                            num40 = 1;
                          }
                          num37 = num37 + 1;
                          num38 = num40;
                          num39 = num40;
                        } while (num37 < length8);
                      }
                      num35 = num35 + num39;
                      tmp65 = diff2;
                      tmp66 = diff2;
                    } while (0 !== num35);
                  }
                  array[diff1] = tmp66;
                  diff1 = diff1 - 1;
                } while (diff1 >= 0);
              }
              const _Array5 = Array;
              const array2 = new Array(length9);
              for (let num41 = 0; num41 < length9; num41 = num41 + 1) {
                array2[num41] = 0;
              }
              let diff3 = length9 - 1;
              let num42 = 0;
              let num43 = 0;
              if (0 <= diff3) {
                do {
                  let sum7 = num42 * 10000000 + array[diff3];
                  let result1 = sum7 / rounded;
                  let tmp79 = diff3;
                  if (0 < result1) {
                    let _Math15 = Math;
                    let rounded4 = Math.floor(result1);
                  } else {
                    let _Math14 = Math;
                    rounded4 = Math.ceil(result1);
                  }
                  num42 = sum7 - rounded4 * rounded;
                  array2[diff3] = rounded4 | 0;
                  diff3 = diff3 - 1;
                  num43 = num42;
                } while (0 <= diff3);
              }
              const items5 = [array2, num43 | 0];
              const items6 = [arrayToSmall(array), arrayToSmall(items5[0])];
              let items9 = items6;
            } else {
              let length2 = result.length;
              const items7 = [];
              let items8 = [];
              result = globalThis;
              let tmp32 = items8;
              if (length2) {
                do {
                  diff4 = length2 - 1;
                  let arr1 = items8.unshift(result[diff4]);
                  let diff5 = items8.length - 1;
                  let tmp8 = items8;
                  let tmp9 = diff5;
                  let tmp10 = diff5;
                  if (0 === items8[diff5]) {
                    do {
                      let diff6 = tmp9 - 1;
                      tmp9 = diff6;
                      tmp10 = diff6;
                      tmp12 = items8[diff6];
                    } while (0 === tmp12);
                  }
                  items8.length = tmp10 + 1;
                  if (items8.length !== value.length) {
                    let num10 = num7;
                    if (items8.length > value.length) {
                      num10 = 1;
                    }
                    let num8 = num10;
                  } else {
                    let diff7 = items8.length - 1;
                    num8 = 0;
                    if (0 <= diff7) {
                      let tmp14 = diff7;
                      while (items8[diff7] === value[diff7]) {
                        diff7 = diff7 - 1;
                        num8 = 0;
                      }
                      let num9 = num7;
                      if (items8[diff7] > value[diff7]) {
                        num9 = 1;
                      }
                      num8 = num9;
                    }
                  }
                  if (num8 < 0) {
                    let arr2 = items7.push(0);
                    let tmp30 = items8;
                  } else {
                    let length12 = items8.length;
                    result = items8[length12 - 1] * 10000000 + items8[length12 - 2];
                    let result2 = result;
                    result = value[length11 - 1] * 10000000 + value[length11 - 2];
                    if (length12 > length11) {
                      result2 = (result + 1) * 10000000;
                    }
                    let _Math4 = Math;
                    let rounded5 = Math.ceil(result2 / result);
                    while (true) {
                      let length = value.length;
                      let _Array = Array;
                      let tmp17 = new.target;
                      let tmp18 = new.target;
                      let tmp19 = length;
                      let array3 = new Array(length);
                      let tmp20 = array3;
                      let tmp21 = rounded5;
                      let num11 = 0;
                      let num12 = 0;
                      let num13 = 0;
                      let num14 = 0;
                      if (0 < length) {
                        do {
                          let sum8 = value[num12] * rounded5 + num11;
                          let _Math5 = Math;
                          let rounded6 = Math.floor(sum8 / 10000000);
                          array3[num12] = sum8 - rounded6 * 10000000;
                          num12 = num12 + 1;
                          num11 = rounded6;
                          num13 = rounded6;
                          num14 = num12;
                        } while (num12 < length);
                      }
                      if (num13 > 0) {
                        do {
                          array3[num14] = num13 % 10000000;
                          let _Math6 = Math;
                          let sum9 = num14 + 1;
                          num13 = Math.floor(num13 / 10000000);
                          num14 = sum9;
                        } while (num13 > 0);
                      }
                      if (array3.length !== items8.length) {
                        let num17 = num7;
                        if (array3.length > items8.length) {
                          num17 = 1;
                        }
                        let num15 = num17;
                      } else {
                        let diff8 = array3.length - 1;
                        num15 = 0;
                        if (0 <= diff8) {
                          let tmp26 = diff8;
                          while (array3[diff8] === items8[diff8]) {
                            diff8 = diff8 - 1;
                            num15 = 0;
                          }
                          let num16 = num7;
                          if (array3[diff8] > items8[diff8]) {
                            num16 = 1;
                          }
                          num15 = num16;
                        }
                      }
                      let tmp27 = rounded5;
                      if (num15 <= 0) {
                        break;
                      } else {
                        rounded5 = rounded5 - 1;
                        tmp27 = rounded5;
                        if (!rounded5) {
                          break;
                        }
                      }
                    }
                    let arr3 = items7.push(tmp27);
                    let tmp29 = subtract;
                    tmp30 = subtract(items8, array3);
                  }
                  items8 = tmp30;
                  tmp32 = tmp30;
                  length2 = diff4;
                } while (diff4);
              }
              const reversed = items7.reverse();
              items9 = [arrayToSmall(items7), arrayToSmall(tmp32)];
            }
            const first = items9[0];
            const sign = value.sign;
            if (typeof first === "number") {
              let tmp85 = first;
              if (tmp83) {
                tmp85 = -first;
              }
              obj = Object.create(SmallInteger.prototype);
              const obj1 = { value: tmp85, sign: tmp85 < 0, isSmall: true };
              let obj2 = obj1;
            } else {
              result = BigInteger;
              result = Object.create(BigInteger.prototype);
              obj2 = { value: first, sign: tmp83, isSmall: false };
            }
            if (typeof items9[1] === "number") {
              let tmp88 = tmp84;
              if (sign) {
                tmp88 = -tmp84;
              }
              Object.create(SmallInteger.prototype);
              const obj4 = { value: tmp88, sign: tmp88 < 0, isSmall: true };
              let obj5 = obj4;
            } else {
              result = BigInteger;
              result = Object.create(BigInteger.prototype);
              obj5 = { value: tmp84, sign, isSmall: false };
            }
            const items10 = [obj2, obj5];
            return items10;
          }
        } else if (1 === value) {
          const items11 = [value, ];
          result = Integer;
          items11[1] = Integer[0];
          return items11;
        } else if (-1 == value) {
          const items12 = [value.negate(), ];
          result = Integer;
          items12[1] = Integer[0];
          return items12;
        } else {
          result = globalThis;
          const _Math20 = Math;
          result = Math.abs(value);
          if (result < 10000000) {
            const _Array6 = Array;
            const array4 = new Array(length10);
            for (let num44 = 0; num44 < length10; num44 = num44 + 1) {
              array4[num44] = 0;
            }
            let diff9 = length10 - 1;
            let num45 = 0;
            let num46 = 0;
            if (0 <= diff9) {
              do {
                result = num45 * 10000000 + result[diff9];
                result = result / result;
                result = diff9;
                if (0 < result) {
                  let _Math17 = Math;
                  result = Math.floor(result);
                } else {
                  let _Math16 = Math;
                  result = Math.ceil(result);
                }
                num45 = result - result * result;
                array4[diff9] = result | 0;
                diff9 = diff9 - 1;
                num46 = num45;
              } while (0 <= diff9);
            }
            const items13 = [array4, num46 | 0];
            result = arrayToSmall(items13[0]);
            result = items13[1];
            if (value.sign) {
              result = -result;
            }
            if (typeof result === "number") {
              if (value.sign !== iter.sign) {
                result = -result;
              }
              result = SmallInteger;
              result = Object.create(SmallInteger.prototype);
              const obj6 = { value: result, sign: result < 0, isSmall: true };
              const items14 = [obj6, ];
              result = Object.create(SmallInteger.prototype);
              const obj7 = { value: result, sign: result < 0, isSmall: true };
              items14[1] = obj7;
              let items15 = items14;
            } else {
              result = BigInteger;
              result = Object.create(BigInteger.prototype);
              const obj8 = { value: result, sign: value.sign !== iter.sign, isSmall: false };
              items15 = [obj8, ];
              result = SmallInteger;
              result = Object.create(SmallInteger.prototype);
              const obj9 = { value: result, sign: result < 0, isSmall: true };
              items15[1] = obj9;
            }
            return items15;
          } else if (result < 10000000) {
            const items16 = [result];
            let items18 = items16;
          } else if (result < 100000000000000) {
            const items17 = [result % 10000000, ];
            const _Math3 = Math;
            items17[1] = Math.floor(result / 10000000);
            items18 = items17;
          } else {
            items18 = [result % 10000000, , ];
            const _Math = Math;
            items18[1] = Math.floor(result / 10000000) % 10000000;
            const _Math2 = Math;
            items18[2] = Math.floor(result / 100000000000000);
          }
        }
      }
    }
  }
}
function millerRabinTest(absResult1, items) {
  let isEvenResult;
  const prevResult = absResult1.prev();
  let num = 0;
  let obj2 = prevResult;
  let num2 = 0;
  let tmp = prevResult;
  if (prevResult.isEven()) {
    do {
      let divideResult = obj2.divide(2);
      num = num + 1;
      obj2 = divideResult;
      num2 = num;
      tmp = divideResult;
      isEvenResult = divideResult.isEven();
    } while (isEvenResult);
  }
  const diff = num2 - 1;
  let num3 = 0;
  if (0 < items.length) {
    while (true) {
      let tmp4 = num3;
      if (!absResult1.lesser(items[num3])) {
        let tmp5 = Integer;
        let obj4 = Integer(items[num3]);
        let modPowResult = obj4.modPow(tmp, absResult1);
        if (!modPowResult.isUnit()) {
          if (!modPowResult.equals(prevResult)) {
            let diff1 = diff;
            if (0 === diff) {
              break;
            } else {
              let squareResult = modPowResult.square();
              let modResult = squareResult.mod(absResult1);
              let tmp7 = diff1;
              while (!modResult.isUnit()) {
                if (!modResult.equals(prevResult)) {
                  diff1 = diff1 - 1;
                  modPowResult = modResult;
                  if (0 !== diff1) {
                    continue;
                  } else {
                    break label0;
                  }
                  let flag = false;
                  return false;
                }
                continue;
              }
              let flag2 = false;
              return false;
            }
          }
        }
      }
      num3 = num3 + 1;
    }
  }
  return true;
}
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 = notResult1;
  let tmp4 = notResult;
  if (!notResult.isZero()) {
    while (true) {
      let tmp6 = closure_19;
      let tmp5 = divModAny;
      let tmp7 = divModAny(tmp4, closure_19);
      let obj4 = tmp7[1];
      let toJSNumberResult = obj4.toJSNumber();
      let tmp9 = tmp3;
      let diff = toJSNumberResult;
      if (isNegativeResult) {
        diff = tmp6 - 1 - toJSNumberResult;
      }
      let tmp5Result = tmp5(tmp3, tmp6);
      let obj5 = tmp5Result[1];
      let toJSNumberResult1 = obj5.toJSNumber();
      let diff1 = toJSNumberResult1;
      if (isNegativeResult1) {
        diff1 = tmp6 - 1 - toJSNumberResult1;
      }
      let first = tmp7[0];
      let first1 = tmp5Result[0];
      let arr = items.push(arg2(diff, diff1));
      tmp3 = first1;
      tmp4 = first;
      if (!first.isZero()) {
        continue;
      } else {
        tmp3 = first1;
        tmp4 = first;
        if (first1.isZero()) {
          break;
        }
      }
      continue;
    }
  } else {
    tmp3 = notResult1;
    tmp4 = notResult;
  }
  let num = 0;
  if (isNegativeResult) {
    num = 1;
  }
  let num2 = 0;
  if (isNegativeResult1) {
    num2 = 1;
  }
  if (0 !== arg2(num, num2)) {
    let tmp16 = Integer(-1);
  } else {
    tmp16 = Integer(0);
  }
  let diff2 = items.length - 1;
  let addResult = tmp16;
  let tmp19 = tmp16;
  if (0 <= diff2) {
    do {
      let tmp20 = closure_19;
      let multiplyResult = addResult.multiply(closure_19);
      let tmp21 = Integer;
      addResult = multiplyResult.add(Integer(items[diff2]));
      diff2 = diff2 - 1;
      tmp19 = addResult;
    } while (0 <= diff2);
  }
  return tmp19;
}
function integerLogarithm(self2, squareResult) {
  let e;
  let p;
  if (squareResult.compareTo(self2) <= 0) {
    ({ p, e } = integerLogarithm(self2, squareResult.square(squareResult)));
    const multiplyResult = p.multiply(squareResult);
    if (multiplyResult.compareTo(self2) <= 0) {
      let obj = { p: null, e: null };
      obj[0] = multiplyResult;
      obj[1] = 2 * e + 1;
    } else {
      obj = { p: null, e: null };
      obj[0] = p;
      obj[1] = 2 * e;
    }
    return obj;
  } else {
    obj = { p: null, e: 0 };
    obj[0] = Integer(1);
    return obj;
  }
}
function gcd(absResult, absResult1) {
  let divideResult2;
  let obj16;
  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 = tmp2;
    let tmp3 = absResult1;
    let obj6 = absResult;
    if (absResult.isEven()) {
      let obj7 = tmp2;
      let iter = absResult1;
      let iter2 = absResult;
      obj5 = tmp2;
      tmp3 = absResult1;
      obj6 = absResult;
      if (absResult1.isEven()) {
        while (true) {
          let value = iter2.value;
          let tmp5 = obj7;
          let tmp6 = iter;
          let tmp7 = iter2;
          if (typeof value === "number") {
            let tmp10 = c21;
            let tmp9 = value | c21;
          } else if (typeof value === "bigint") {
            let _BigInt = BigInt;
            let tmp8 = c21;
            tmp9 = value | BigInt(c21);
          } else {
            tmp9 = value[0] + value[1] * 10000000 | 1073758208;
          }
          value = iter.value;
          let tmp11 = tmp9 & -tmp9;
          if (typeof value === "number") {
            let tmp14 = c21;
            let tmp13 = value | c21;
          } else if (typeof value === "bigint") {
            let _BigInt2 = BigInt;
            let tmp12 = c21;
            tmp13 = value | BigInt(c21);
          } else {
            tmp13 = value[0] + value[1] * 10000000 | 1073758208;
          }
          let tmp16 = parseValue;
          let tmp15 = tmp13 & -tmp13;
          let obj8 = parseValue(tmp11);
          let tmp17 = parseValue(tmp15);
          if (obj8.lesser(tmp17)) {
            tmp17 = obj8;
          }
          let divideResult = iter2.divide(tmp17);
          let divideResult1 = iter.divide(tmp17);
          let multiplyResult = obj7.multiply(tmp17);
          obj5 = multiplyResult;
          tmp3 = divideResult1;
          obj6 = divideResult;
          if (!divideResult.isEven()) {
            break;
          } else {
            obj7 = multiplyResult;
            iter = divideResult1;
            iter2 = divideResult;
            obj5 = multiplyResult;
            tmp3 = divideResult1;
            obj6 = divideResult;
            if (!divideResult1.isEven()) {
              break;
            }
          }
        }
      }
    }
    let iter3 = obj6;
    let obj11 = tmp3;
    let obj12 = obj6;
    if (obj6.isEven()) {
      do {
        value = iter3.value;
        let tmp20 = iter3;
        if (typeof value === "number") {
          let tmp23 = c21;
          let tmp22 = value | c21;
        } else if (typeof value === "bigint") {
          let _BigInt3 = BigInt;
          let tmp21 = c21;
          tmp22 = value | BigInt(c21);
        } else {
          tmp22 = value[0] + value[1] * 10000000 | 1073758208;
        }
        divideResult2 = iter3.divide(tmp22 & -tmp22);
        iter3 = divideResult2;
        obj11 = tmp3;
        obj12 = divideResult2;
      } while (divideResult2.isEven());
    }
    do {
      let iter4 = obj11;
      let tmp24 = obj12;
      let tmp25 = obj11;
      if (obj11.isEven()) {
        do {
          let value1 = iter4.value;
          let tmp26 = iter4;
          if (typeof value1 === "number") {
            let tmp29 = c21;
            let tmp28 = value1 | c21;
          } else if (typeof value1 === "bigint") {
            let _BigInt4 = BigInt;
            let tmp27 = c21;
            tmp28 = value1 | BigInt(c21);
          } else {
            tmp28 = value1[0] + value1[1] * 10000000 | 1073758208;
          }
          divideResult3 = iter4.divide(tmp28 & -tmp28);
          iter4 = divideResult3;
          tmp25 = divideResult3;
        } while (divideResult3.isEven());
      }
      let obj15 = tmp25;
      obj16 = obj12;
      if (obj12.greater(tmp25)) {
        obj15 = obj12;
        obj16 = tmp25;
      }
      subtractResult = obj15.subtract(obj16);
      obj11 = subtractResult;
      obj12 = obj16;
    } while (!subtractResult.isZero());
    let multiplyResult1 = obj16;
    if (!obj5.isUnit()) {
      multiplyResult1 = obj16.multiply(obj5);
    }
    return multiplyResult1;
  }
  const obj3 = parseValue(absResult1);
}
function toBase(self, arg1) {
  let quotient;
  let remainder;
  let obj = Integer(arg1);
  if (obj.isZero()) {
    if (self.isZero()) {
      obj = { value: null, isNegative: false };
      obj[0] = [0];
      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 (self.isZero()) {
      obj = { value: null, isNegative: false };
      obj[0] = [0];
      return obj;
    } else if (self.isNegative()) {
      const obj1 = { value: null, isNegative: false };
      const concat2 = [].concat;
      const _Array6 = Array;
      const _Array7 = Array;
      const _Array8 = Array;
      obj1[0] = concat2.apply([], Array.apply(null, Array(-self.toJSNumber())).map(Array.prototype.valueOf, [1, 0]));
      return obj1;
    } else {
      const _Array3 = Array;
      const _Array4 = Array;
      const _Array5 = Array;
      const mapped = Array.apply(null, Array(self.toJSNumber() - 1)).map(Array.prototype.valueOf, [0, 1]);
      mapped.unshift([1]);
      let obj2 = { value: null, isNegative: false };
      const concat = [].concat;
      obj2[0] = concat.apply([], mapped);
      return obj2;
    }
  } else {
    let flag = false;
    let absResult = self;
    if (tmp) {
      absResult = self.abs();
      flag = true;
    }
    if (obj.isUnit()) {
      if (absResult.isZero()) {
        let obj3 = { value: null, isNegative: false };
        obj3[0] = [0];
        let obj4 = obj3;
      } else {
        obj4 = { value: null, isNegative: null };
        const _Array = Array;
        const _Array2 = Array;
        const _Number = Number;
        obj4[0] = Array.apply(null, Array(absResult.toJSNumber())).map(Number.prototype.valueOf, 1);
        obj4[1] = flag;
        const applyResult2 = Array.apply(null, Array(absResult.toJSNumber()));
      }
      return obj4;
    } else {
      const items = [];
      obj2 = absResult;
      if (absResult.isNegative()) {
        while (true) {
          let divmodResult = obj2.divmod(obj);
          ({ quotient, remainder } = divmodResult);
          let absResult1 = remainder;
          let nextResult = quotient;
          if (remainder.isNegative()) {
            let minusResult = obj.minus(remainder);
            absResult1 = minusResult.abs();
            nextResult = quotient.next();
          }
          let arr = items.push(absResult1.toJSNumber());
          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 obj5 = { value: null, isNegative: null };
      obj5[0] = items.reverse();
      obj5[1] = flag;
      return obj5;
    }
    tmp = self.isNegative() && obj.isPositive();
  }
}
function parseStringValue(arr) {
  let tmp28;
  let tmp2 = -9007199254740992 < tmp;
  if (-9007199254740992 < +arr) {
    tmp2 = tmp < 9007199254740992;
  }
  if (tmp2) {
    if (0 < +arr) {
      const _Math4 = Math;
      let rounded = Math.floor(tmp51);
    } else {
      const _Math3 = Math;
      rounded = Math.ceil(tmp51);
    }
    if (+arr === rounded) {
      if (closure_2) {
        const _BigInt = BigInt;
        let obj = Object.create(NativeBigInt.prototype);
        obj.value = BigInt(tmp51);
        let obj1 = obj;
        const BigIntResult = BigInt(tmp51);
      } else {
        obj = Object.create(SmallInteger.prototype);
        obj1 = { value: tmp51, sign: tmp51 < 0, isSmall: true };
      }
      return obj1;
    } 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 (0 < +substr) {
          const _Math2 = Math;
          let rounded1 = Math.floor(tmp5);
        } else {
          const _Math = Math;
          rounded1 = Math.ceil(tmp5);
        }
        if (+substr === rounded1) {
          let tmp9 = -9007199254740992 < tmp5;
          if (-9007199254740992 < tmp5) {
            tmp9 = tmp5 < 9007199254740992;
          }
          if (tmp9) {
            const first = parts[0];
            const index = first.indexOf(".");
            let sum = first;
            let diff = tmp5;
            if (index >= 0) {
              diff = tmp5 - (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: " + tmp5 + " is not a valid exponent.");
        throw error3;
      }
      obj = /^([0-9][0-9]*)$/;
      if (obj.test(str2)) {
        if (closure_2) {
          let text = str2;
          if (tmp3) {
            text = `-${str2}`;
          }
          const obj2 = Object.create(NativeBigInt.prototype);
          obj2.value = BigInt(text);
          return obj2;
        } else {
          const items = [];
          let length = str2.length;
          let diff1 = length - 7;
          if (length > 0) {
            do {
              arr = items.push(+str2.slice(diff1, length));
              let num10 = diff1 - 7;
              let tmp23 = length;
              if (num10 < 0) {
                num10 = 0;
              }
              length = length - 7;
              diff1 = num10;
            } while (0 < length);
          }
          const diff2 = items.length - 1;
          let tmp25 = diff2;
          let tmp26 = diff2;
          if (0 === items[diff2]) {
            do {
              let diff3 = tmp25 - 1;
              tmp25 = diff3;
              tmp26 = diff3;
              tmp28 = items[diff3];
            } while (0 === tmp28);
          }
          items.length = tmp26 + 1;
          Object.create(BigInteger.prototype);
          const obj4 = { value: items, sign: tmp3, isSmall: false };
          return obj4;
        }
      } else {
        const _Error = Error;
        const error4 = new Error("Invalid integer: " + str2);
        throw error4;
      }
    }
  }
}
function parseValue(result) {
  if (typeof result === "number") {
    if (closure_2) {
      const _BigInt = BigInt;
      let obj = Object.create(NativeBigInt.prototype);
      obj.value = BigInt(result);
      let tmp6 = obj;
      const BigIntResult = BigInt(result);
    } else {
      let tmp4 = -9007199254740992 < result;
      if (tmp4) {
        tmp4 = result < 9007199254740992;
      }
      if (!tmp4) {
        tmp6 = parseStringValue(result.toString());
      }
    }
    if (result > 0) {
      const _Math2 = Math;
      let rounded = Math.floor(result);
    } else {
      const _Math = Math;
      rounded = Math.ceil(result);
    }
    if (result !== rounded) {
      const _Error = Error;
      const error = new Error(result + " is not an integer.");
      throw error;
    } else {
      obj = Object.create(SmallInteger.prototype);
      obj = { value: result, sign: result < 0, isSmall: true };
      tmp6 = obj;
    }
  } else {
    if (typeof result === "string") {
      let tmp2 = parseStringValue(result);
    } else {
      tmp2 = result;
      if (typeof result === "bigint") {
        const obj1 = Object.create(NativeBigInt.prototype);
        obj1.value = result;
        tmp2 = obj1;
      }
    }
    return tmp2;
  }
}
let items = [4740992, Math.floor(900719925.4740992) % 10000000, Math.floor(90.07199254740992)];
const Integer = items;
let c1 = "0123456789abcdefghijklmnopqrstuvwxyz";
let closure_2 = typeof BigInt === "function";
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) {
  const result = this.value / parseValue(arg0).value;
  const obj = Object.create(NativeBigInt.prototype);
  obj.value = result;
  return obj;
};
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) {
  const result = this.value % parseValue(arg0).value;
  const obj = Object.create(NativeBigInt.prototype);
  obj.value = result;
  return obj;
};
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 items1 = [1];
if (2 * items1[items1.length - 1] <= 10000000) {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
}
let length = items1.length;
let closure_19 = items1[length - 1];
const 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 c21 = 1073741824;
const bitLength = BigInteger.prototype.bitLength;
SmallInteger.prototype.bitLength = bitLength;
NativeBigInt.prototype.bitLength = bitLength;
function parseBase(arg0, arg1, arg2, arg3) {

}
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;
while (true) {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
  let tmp = num;
  if (0 < num) {
    class Integer {
      constructor(arg0, arg1, arg2, arg3) {
        if (undefined === arg0) {
          tmp32 = Integer;
          first = Integer[0];
        } else {
          tmp33 = arg1;
          if (undefined !== arg1) {
            str = arg2;
            num = 10;
            if (10 === +arg1) {
            }
            tmp3 = parseBase;
            if (typeof parseBase !== "function") {
              str10 = "Trying to call a non-function";
              throwTypeErrorResult = HermesBuiltin.throwTypeError();
            }
            if (!str) {
              str = c1;
            }
            tmp4 = arg3;
            tmp5 = globalThis;
            _String = String;
            str2 = String(arg0);
            formatted1 = str;
            formatted = str2;
            if (!arg3) {
              formatted = str2.toLowerCase();
              formatted1 = str.toLowerCase();
            }
            length = formatted.length;
            _Math = Math;
            absolute = Math.abs(arg1);
            obj = {};
            num2 = 0;
            num3 = 1;
            num4 = 0;
            if (0 < formatted1.length) {
              do {
                obj[formatted1[num4]] = num4;
                num4 = num4 + 1;
                length2 = formatted1.length;
              } while (num4 < length2);
            }
            str3 = "1";
            str4 = "-";
            num5 = 0;
            if (0 < length) {
              while (true) {
                tmp7 = formatted[num5];
                tmp8 = num5;
                if ("-" !== tmp7) {
                  if (tmp7 in obj) {
                    if (obj[tmp7] >= absolute) {
                      if ("1" !== tmp7) {
                        break;
                      } else if (1 !== absolute) {
                        break;
                      }
                    }
                  }
                }
                num5 = num5 + 1;
              }
              _Error = Error;
              str5 = " is not a valid digit in base ";
              tmp9 = new.target;
              str6 = ".";
              tmp10 = new.target;
              error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
              tmp12 = error;
              throw error;
            }
            tmp13 = parseValue;
            tmp15 = "-" === formatted[0];
            num6 = 0;
            tmp14 = parseValue(arg1);
            if (tmp15) {
              num6 = 1;
            }
            items = [];
            str7 = "<";
            str8 = ">";
            if (num6 < formatted.length) {
              while (true) {
                tmp16 = formatted[num6];
                tmp17 = num6;
                if (tmp16 in obj) {
                  tmp26 = parseValue;
                  arr = items.push(parseValue(obj[tmp16]));
                  sum = num6;
                } else {
                  tmp18 = num6;
                  if ("<" !== tmp16) {
                    break;
                  } else {
                    sum = tmp18 + 1;
                    while (">" !== formatted[sum]) {
                      tmp18 = sum;
                      if (sum >= formatted.length) {
                        break;
                      }
                    }
                    tmp20 = parseValue;
                    arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                  }
                }
                num6 = sum + 1;
              }
              _Error2 = Error;
              str9 = " is not a valid character";
              tmp22 = new.target;
              tmp23 = new.target;
              error1 = new Error(tmp16 + " is not a valid character");
              tmp25 = error1;
              throw error1;
            }
            tmp28 = Integer;
            [tmp29, obj2] = Integer;
            diff = items.length - 1;
            addResult = tmp29;
            obj4 = tmp29;
            if (0 <= diff) {
              do {
                obj5 = items[diff];
                addResult = addResult.add(obj5.times(timesResult));
                timesResult = timesResult.times(tmp14);
                diff = diff - 1;
                obj4 = addResult;
              } while (0 <= diff);
            }
            negateResult = obj4;
            if (tmp15) {
              negateResult = obj4.negate();
            }
            first = negateResult;
          }
          tmp = parseValue;
          first = parseValue(arg0);
        }
        return first;
      }
    }
    Integer[tmp2] = parseValue(tmp2);
  }
  class BigInteger {
    constructor(arg0, arg1) {
      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;
        tmp17 = BigInteger;
        if (iter.isSmall) {
          tmp4 = globalThis;
          _Math = Math;
          absolute = Math.abs(value);
          length = value.length;
          _Array = Array;
          tmp6 = new.target;
          tmp7 = new.target;
          tmp8 = length;
          array = new Array(length);
          tmp10 = array;
          num2 = 0;
          num3 = 10000000;
          num4 = 1;
          num5 = 0;
          sum1 = absolute;
          num6 = 0;
          rounded1 = absolute;
          if (0 < length) {
            do {
              sum = value[num5] - 10000000 + sum1;
              _Math2 = Math;
              rounded = Math.floor(sum / 10000000);
              array[num5] = sum - rounded * 10000000;
              sum1 = rounded + 1;
              num5 = num5 + 1;
              rounded1 = sum1;
              num6 = num5;
            } while (num5 < length);
          }
          if (rounded1 > 0) {
            do {
              array[num6] = rounded1 % 10000000;
              _Math3 = Math;
              sum2 = num6 + 1;
              rounded1 = Math.floor(rounded1 / 10000000);
              num6 = sum2;
            } while (rounded1 > 0);
          }
          obj = Object.create(tmp17.prototype);
          obj1 = {};
          obj1.value = array;
          obj1.sign = self.sign;
          flag2 = false;
          obj1.isSmall = false;
          obj = obj1;
        } else {
          tmp = addAny;
          num = 0;
          tmp2 = addAny(value, value);
          obj2 = Object.create(tmp17.prototype);
          obj = {};
          obj.value = tmp2;
          obj.sign = self.sign;
          flag = false;
          obj.isSmall = false;
        }
        return obj;
      }
    }
    subtract(arg0) {
      self = this;
      iter = parseValue(arg0);
      if (this.sign !== iter.sign) {
        return self.add(iter.negate());
      } else {
        value = self.value;
        value1 = iter.value;
        if (iter.isSmall) {
          tmp12 = subtractSmall;
          tmp13 = globalThis;
          _Math = Math;
          num7 = 0;
          obj2 = subtractSmall(value, Math.abs(value1), self.sign);
        } else {
          sign = self.sign;
          if (value.length !== value1.length) {
            num5 = -1;
            if (value.length > value1.length) {
              num5 = 1;
            }
            num3 = num5;
          } else {
            num = 1;
            diff = value.length - 1;
            num2 = 0;
            num3 = 0;
            if (0 <= diff) {
              tmp2 = diff;
              while (value[diff] === value1[diff]) {
                diff = diff - 1;
                num3 = 0;
              }
              num4 = -1;
              if (value[diff] > value1[diff]) {
                num4 = 1;
              }
              num3 = num4;
            }
          }
          num6 = 0;
          if (0 <= num3) {
            tmp6 = subtract;
            tmp4 = subtract(value, value1);
            tmp5 = sign;
          } else {
            tmp3 = subtract;
            tmp4 = subtract(value1, value);
            tmp5 = !sign;
          }
          tmp7 = arrayToSmall;
          tmp8 = arrayToSmall(tmp4);
          if (typeof tmp8 === "number") {
            tmp9 = tmp8;
            if (tmp5) {
              tmp9 = -tmp8;
            }
            tmp10 = SmallInteger;
            obj = Object.create(SmallInteger.prototype);
            obj = {};
            obj.value = tmp9;
            obj.sign = tmp9 < 0;
            flag = true;
            obj.isSmall = true;
            obj2 = obj;
          } else {
            tmp14 = BigInteger;
            obj1 = Object.create(BigInteger.prototype);
            obj2 = {};
            obj2.value = tmp8;
            obj2.sign = tmp5;
            flag2 = false;
            obj2.isSmall = false;
          }
        }
        return obj2;
      }
    }
    negate() {
      sign = !this.sign;
      obj = Object.create(BigInteger.prototype);
      return { value: this.value, sign, isSmall: false };
    }
    abs() {
      obj = Object.create(BigInteger.prototype);
      return { value: this.value, sign: false, isSmall: false };
    }
    multiply(arg0) {
      self = this;
      iter = parseValue(arg0);
      value = this.value;
      value1 = iter.value;
      tmp = this.sign !== iter.sign;
      if (!iter.isSmall) {
        length = value.length;
        length2 = value1.length;
        num2 = -0.012;
        num3 = 0.012;
        num4 = 0.000015;
        num5 = 0;
        if (0 < -0.012 * length - 0.012 * length2 + 0.000015 * length * length2) {
          tmp7 = BigInteger;
          tmp8 = multiplyKaratsuba;
          tmp9 = multiplyKaratsuba(value, value1);
          obj = Object.create(BigInteger.prototype);
          obj1 = {};
          obj1.value = tmp9;
          obj1.sign = tmp;
          flag2 = false;
          obj1.isSmall = false;
          obj = obj1;
        } else {
          tmp3 = BigInteger;
          tmp4 = multiplyLong;
          tmp5 = multiplyLong(value, value1);
          obj2 = Object.create(BigInteger.prototype);
          obj = {};
          obj.value = tmp5;
          obj.sign = tmp;
          flag = false;
          obj.isSmall = false;
        }
        return obj;
      } else {
        num = 0;
        if (0 === value1) {
          tmp21 = Integer;
          return Integer[0];
        } else {
          num10 = 1;
          if (1 === value1) {
            return self;
          } else {
            num11 = -1;
            if (-1 === value1) {
              return self.negate();
            } else {
              tmp22 = globalThis;
              _Math6 = Math;
              absolute = Math.abs(value1);
              num12 = 10000000;
              if (absolute < 10000000) {
                length3 = value.length;
                _Array = Array;
                tmp12 = new.target;
                tmp13 = new.target;
                tmp14 = length3;
                tmp11 = BigInteger;
                array = new Array(length3);
                tmp16 = array;
                num6 = 0;
                num7 = 0;
                num8 = 0;
                num9 = 0;
                if (0 < length3) {
                  do {
                    sum = value[num7] * absolute + num6;
                    _Math4 = Math;
                    rounded = Math.floor(sum / 10000000);
                    array[num7] = sum - rounded * 10000000;
                    num7 = num7 + 1;
                    num6 = rounded;
                    num8 = rounded;
                    num9 = num7;
                  } while (num7 < length3);
                }
                if (num8 > 0) {
                  do {
                    array[num9] = num8 % 10000000;
                    _Math5 = Math;
                    sum1 = num9 + 1;
                    num8 = Math.floor(num8 / 10000000);
                    num9 = sum1;
                  } while (num8 > 0);
                }
                obj3 = Object.create(tmp11.prototype);
                obj4 = {};
                obj4.value = array;
                obj4.sign = tmp;
                flag3 = false;
                obj4.isSmall = false;
                return obj4;
              } else {
                if (absolute < 10000000) {
                  items = [];
                  items[0] = absolute;
                  items2 = items;
                } else {
                  num13 = 100000000000000;
                  if (absolute < 100000000000000) {
                    items1 = [, ];
                    items1[0] = absolute % 10000000;
                    _Math3 = Math;
                    items1[1] = Math.floor(absolute / 10000000);
                    items2 = items1;
                  } else {
                    items2 = [, , ];
                    items2[0] = absolute % 10000000;
                    _Math = Math;
                    items2[1] = Math.floor(absolute / 10000000) % 10000000;
                    _Math2 = Math;
                    items2[2] = Math.floor(absolute / 100000000000000);
                  }
                }
                tmp2 = items2;
              }
            }
          }
        }
      }
      return;
    }
    _multiplyBySmall(arg0) {
      if (0 === arg0.value) {
        tmp5 = Integer;
        self2 = Integer[0];
      } else {
        self = this;
        num = 1;
        self2 = this;
        if (1 !== arg0.value) {
          num2 = -1;
          if (-1 === arg0.value) {
            negateResult = self.negate();
          } else {
            tmp = multiplySmallAndArray;
            tmp2 = globalThis;
            _Math = Math;
            negateResult = multiplySmallAndArray(Math.abs(arg0.value), self.value, self.sign !== arg0.sign);
          }
          tmp4 = negateResult;
        }
      }
      return self2;
    }
    square() {
      value = square(this.value);
      obj = Object.create(BigInteger.prototype);
      return { value, sign: false, isSmall: false };
    }
    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) {
        tmp25 = Integer;
        return Integer[1];
      } else if (0 === value) {
        tmp24 = Integer;
        return Integer[0];
      } else {
        num4 = 1;
        if (1 === value) {
          tmp23 = Integer;
          return Integer[1];
        } else {
          num5 = -1;
          if (-1 === value) {
            tmp22 = Integer;
            return iter.isEven() ? tmp22[1] : tmp22[-1];
          } else if (iter.sign) {
            tmp21 = Integer;
            return Integer[0];
          } else if (iter.isSmall) {
            if (self.isSmall) {
              tmp6 = globalThis;
              _Math = Math;
              powResult = Math.pow(value, value);
              num = -9007199254740992;
              tmp8 = -9007199254740992 < powResult;
              if (tmp8) {
                num2 = 9007199254740992;
                tmp8 = powResult < 9007199254740992;
              }
              if (tmp8) {
                tmp18 = SmallInteger;
                if (powResult > 0) {
                  _Math3 = Math;
                  rounded = Math.floor(powResult);
                } else {
                  _Math2 = Math;
                  rounded = Math.ceil(powResult);
                }
                obj = Object.create(tmp18.prototype);
                obj1 = {};
                obj1.value = rounded;
                obj1.sign = rounded < 0;
                flag2 = true;
                obj1.isSmall = true;
                return obj1;
              }
            }
            tmp9 = Integer;
            obj = Integer[1];
            flag = true;
            diff = value;
            timesResult = obj;
            if (true & value) {
              timesResult = obj.times(self);
              diff = value - 1;
            }
            num3 = 2;
            obj2 = timesResult;
            tmp12 = timesResult;
            if (0 !== diff) {
              do {
                result = diff / 2;
                squareResult = self.square();
                tmp15 = obj2;
                diff1 = result;
                timesResult1 = obj2;
                if (true & result) {
                  timesResult1 = obj2.times(squareResult);
                  diff1 = result - 1;
                }
                diff = diff1;
                obj2 = timesResult1;
                self = squareResult;
                tmp12 = timesResult1;
              } while (0 !== diff1);
            }
            return tmp12;
          } else {
            tmp = globalThis;
            _Error = Error;
            str = "The exponent ";
            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) {
      obj = parseValue(arg0);
      obj2 = parseValue(arg1);
      if (obj2.isZero()) {
        tmp9 = globalThis;
        _Error = Error;
        tmp10 = new.target;
        str = "Cannot take modPow with modulus 0";
        tmp11 = new.target;
        error = new Error("Cannot take modPow with modulus 0");
        tmp13 = error;
        throw error;
      } else {
        self = this;
        tmp2 = Integer[1];
        tmp = Integer;
        modResult = this.mod(obj2);
        modInvResult = modResult;
        multiplyResult = obj;
        if (obj.isNegative()) {
          num = -1;
          multiplyResult = obj.multiply(tmp[-1]);
          modInvResult = modResult.modInv(obj2);
        }
        num2 = 2;
        obj6 = multiplyResult;
        obj7 = tmp2;
        tmp3 = tmp2;
        if (multiplyResult.isPositive()) {
          tmp4 = modInvResult;
          tmp5 = obj7;
          tmp6 = obj6;
          while (!modInvResult.isZero()) {
            modResult1 = obj7;
            if (obj6.isOdd()) {
              multiplyResult1 = obj7.multiply(modInvResult);
              modResult1 = multiplyResult1.mod(obj2);
            }
            divideResult = require("module_2");
            squareResult = modInvResult.square();
            modInvResult = squareResult.mod(obj2);
            obj7 = modResult1;
            obj6 = divideResult;
            tmp3 = modResult1;
          }
          tmp8 = Integer;
          return Integer[0];
        }
        return tmp3;
      }
    }
    compareAbs(arg0) {
      iter = parseValue(arg0);
      value = this.value;
      value1 = iter.value;
      if (iter.isSmall) {
        return 1;
      } else {
        if (value.length !== value1.length) {
          value = value.length;
          value1 = value1.length;
          num3 = -1;
          if (value > value1) {
            num3 = 1;
          }
          num2 = num3;
        } else {
          diff = value.length - 1;
          num = 0;
          num2 = 0;
          if (0 <= diff) {
            num3 = diff;
            while (value[diff] === value1[diff]) {
              diff = num3 - 1;
              num2 = 0;
            }
          }
          tmp2 = value[num3] > value1[num3];
          num3 = -1;
          if (tmp2) {
            num3 = 1;
          }
          num2 = num3;
        }
        tmp3 = num2;
      }
      return;
    }
    compare(arg0) {
      if (arg0 === Infinity) {
        num10 = -1;
        return -1;
      } else {
        num11 = -Infinity;
        if (arg0 === -Infinity) {
          num9 = 1;
          return 1;
        } else {
          self = this;
          tmp4 = parseValue;
          iter = parseValue(arg0);
          value = this.value;
          value1 = iter.value;
          if (this.sign !== iter.sign) {
            num8 = -1;
            if (iter.sign) {
              num8 = 1;
            }
            result = num8;
          } else if (iter.isSmall) {
            num7 = 1;
            if (self.sign) {
              num7 = -1;
            }
            result = num7;
          } else {
            if (value.length !== value1.length) {
              num5 = -1;
              if (value.length > value1.length) {
                num5 = 1;
              }
              num3 = num5;
            } else {
              num = 1;
              diff = value.length - 1;
              num2 = 0;
              num3 = 0;
              if (0 <= diff) {
                tmp2 = diff;
                while (value[diff] === value1[diff]) {
                  diff = diff - 1;
                  num3 = 0;
                }
                num4 = -1;
                if (value[diff] > value1[diff]) {
                  num4 = 1;
                }
                num3 = num4;
              }
            }
            num6 = 1;
            if (self.sign) {
              num6 = -1;
            }
            result = num3 * num6;
          }
          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) {
      obj = parseValue(arg0);
      isZeroResult = obj.isZero();
      tmp2 = !isZeroResult;
      if (!isZeroResult) {
        tmp3 = obj.isUnit();
        if (tmp3) {
          tmp2 = tmp3;
        } else {
          self = this;
          num = 2;
          num2 = 0;
          if (0 === require("module_2")) {
            isEvenResult = self.isEven();
          } else {
            modResult = self.mod(obj);
            isEvenResult = modResult.isZero();
          }
          tmp5 = isEvenResult;
        }
      }
      return tmp2;
    }
    isPrime(arg0) {
      self = this;
      absResult = this.abs();
      isUnitResult = absResult.isUnit();
      tmp2 = !isUnitResult;
      if (!isUnitResult) {
        num = 2;
        equalsResult = require("module_2");
        if (!equalsResult) {
          num2 = 3;
          equalsResult = require("module_3");
        }
        if (!equalsResult) {
          num3 = 5;
          equalsResult = require("module_5");
        }
        tmp4 = equalsResult;
        if (!tmp4) {
          isEvenResult = absResult.isEven();
          if (!isEvenResult) {
            num4 = 3;
            isEvenResult = require("module_3");
          }
          if (!isEvenResult) {
            num5 = 5;
            isEvenResult = require("module_5");
          }
          tmp6 = !isEvenResult;
          if (!isEvenResult) {
            num6 = 49;
            tmp7 = require("module_49") || undefined;
            tmp6 = tmp7;
          }
          tmp4 = tmp6;
        }
        tmp2 = tmp4;
      }
      if (tmp2 !== undefined) {
        return tmp2;
      } else {
        absResult1 = self.abs();
        bitLengthResult = absResult1.bitLength();
        num11 = 64;
        if (bitLengthResult <= 64) {
          tmp13 = millerRabinTest;
          num10 = 0;
          return millerRabinTest(absResult1, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
        } else {
          tmp14 = arg0;
          tmp15 = globalThis;
          _Math2 = Math;
          num12 = 2;
          logResult = require("module_2");
          result = logResult * bitLengthResult.toJSNumber();
          flag = true;
          result1 = result;
          if (true === arg0) {
            _Math = Math;
            result1 = 2 * Math.pow(result, 2);
          }
          rounded = Math.ceil(result1);
          items = [];
          num7 = 0;
          num8 = 1;
          for (let num9 = 0; num9 < rounded; num9 = num9 + 1) {
            tmp10 = Integer;
            arr = items.push(Integer(num9 + 2));
          }
          tmp12 = millerRabinTest;
          return millerRabinTest(absResult1, items);
        }
      }
    }
    isProbablePrime(arg0, arg1) {
      self = this;
      absResult = this.abs();
      isUnitResult = absResult.isUnit();
      tmp2 = !isUnitResult;
      if (!isUnitResult) {
        num = 2;
        equalsResult = require("module_2");
        if (!equalsResult) {
          num2 = 3;
          equalsResult = require("module_3");
        }
        if (!equalsResult) {
          num3 = 5;
          equalsResult = require("module_5");
        }
        tmp4 = equalsResult;
        if (!tmp4) {
          isEvenResult = absResult.isEven();
          if (!isEvenResult) {
            num4 = 3;
            isEvenResult = require("module_3");
          }
          if (!isEvenResult) {
            num5 = 5;
            isEvenResult = require("module_5");
          }
          tmp6 = !isEvenResult;
          if (!isEvenResult) {
            num6 = 49;
            tmp7 = require("module_49") || undefined;
            tmp6 = tmp7;
          }
          tmp4 = tmp6;
        }
        tmp2 = tmp4;
      }
      if (tmp2 !== undefined) {
        return tmp2;
      } else {
        tmp8 = arg0;
        absResult1 = self.abs();
        num7 = 5;
        if (arg0 !== undefined) {
          num7 = arg0;
        }
        items = [];
        num8 = 0;
        num9 = 2;
        num10 = 1;
        for (let num11 = 0; num11 < num7; num11 = num11 + 1) {
          tmp9 = Integer;
          arr = items.push(require("module_2"));
        }
        tmp11 = millerRabinTest;
        return millerRabinTest(absResult1, items);
      }
    }
    modInv(arg0) {
      self = this;
      ({ zero, one } = Integer);
      obj = parseValue(arg0);
      absResult = this.abs();
      tmp = absResult;
      obj3 = zero;
      obj4 = obj;
      obj5 = zero;
      if (!absResult.isZero()) {
        do {
          divideResult = obj.divide(tmp);
          subtractResult = obj3.subtract(divideResult.multiply(one));
          subtractResult1 = obj.subtract(divideResult.multiply(tmp));
          obj = tmp;
          obj3 = one;
          tmp = subtractResult1;
          one = subtractResult;
          obj4 = obj;
          obj5 = obj3;
          isZeroResult = subtractResult1.isZero();
        } while (!isZeroResult);
      }
      if (obj4.isUnit()) {
        num = 0;
        num2 = -1;
        addResult = obj5;
        if (-1 === require("module_0")) {
          addResult = obj5.add(arg0);
        }
        negateResult = addResult;
        if (self.isNegative()) {
          negateResult = addResult.negate();
        }
        return negateResult;
      } else {
        tmp4 = globalThis;
        _Error = Error;
        str = " and ";
        text = `${self.toString()} and `;
        tmp6 = new.target;
        str2 = " are not co-prime";
        tmp7 = new.target;
        error = new Error(`${self.toString()} and ` + arg0.toString() + " are not co-prime");
        tmp9 = error;
        throw error;
      }
    }
    next() {
      self = this;
      value = this.value;
      if (this.sign) {
        tmp12 = subtractSmall;
        num8 = 1;
        num9 = 0;
        obj = subtractSmall(value, 1, self.sign);
      } else {
        length = value.length;
        tmp2 = globalThis;
        _Array = Array;
        tmp3 = new.target;
        tmp4 = new.target;
        tmp5 = length;
        tmp = BigInteger;
        array = new Array(length);
        tmp7 = array;
        num = 0;
        num2 = 1;
        num3 = 10000000;
        num4 = 0;
        num5 = 1;
        num6 = 0;
        num7 = 1;
        if (0 < length) {
          do {
            sum = value[num4] - 10000000 + num5;
            _Math = Math;
            rounded = Math.floor(sum / 10000000);
            array[num4] = sum - rounded * 10000000;
            num5 = rounded + 1;
            num4 = num4 + 1;
            num7 = num5;
            num6 = num4;
          } while (num4 < length);
        }
        if (num7 > 0) {
          do {
            array[num6] = num7 % 10000000;
            _Math2 = Math;
            sum1 = num6 + 1;
            num7 = Math.floor(num7 / 10000000);
            num6 = sum1;
          } while (num7 > 0);
        }
        obj = Object.create(tmp.prototype);
        obj = {};
        obj.value = array;
        obj.sign = self.sign;
        flag = false;
        obj.isSmall = false;
      }
      return obj;
    }
    prev() {
      value = this.value;
      if (this.sign) {
        length = value.length;
        tmp5 = globalThis;
        _Array = Array;
        tmp6 = new.target;
        tmp7 = new.target;
        tmp8 = length;
        tmp4 = BigInteger;
        array = new Array(length);
        tmp10 = array;
        num3 = 0;
        num4 = 1;
        num5 = 10000000;
        num6 = 0;
        num7 = 1;
        num8 = 0;
        num9 = 1;
        if (0 < length) {
          do {
            sum = value[num6] - 10000000 + num7;
            _Math = Math;
            rounded = Math.floor(sum / 10000000);
            array[num6] = sum - rounded * 10000000;
            num7 = rounded + 1;
            num6 = num6 + 1;
            num9 = num7;
            num8 = num6;
          } while (num6 < length);
        }
        if (num9 > 0) {
          do {
            array[num8] = num9 % 10000000;
            _Math2 = Math;
            sum1 = num8 + 1;
            num9 = Math.floor(num9 / 10000000);
            num8 = sum1;
          } while (num9 > 0);
        }
        obj = Object.create(tmp4.prototype);
        obj = {};
        obj.value = array;
        flag = true;
        obj.sign = true;
        flag2 = false;
        obj.isSmall = false;
        tmp3 = obj;
      } else {
        tmp2 = subtractSmall;
        num = 1;
        num2 = 0;
        tmp3 = subtractSmall(value, 1, tmp.sign);
      }
      return tmp3;
    }
    shiftLeft(arg0) {
      obj = parseValue(arg0);
      toJSNumberResult = obj.toJSNumber();
      if (Math.abs(toJSNumberResult) <= 10000000) {
        self = this;
        num = 0;
        if (toJSNumberResult < 0) {
          return self.shiftRight(-toJSNumberResult);
        } else if (self.isZero()) {
          return self;
        } else {
          tmp6 = length;
          num2 = 1;
          multiplyResult = self;
          diff = toJSNumberResult;
          obj3 = self;
          tmp8 = toJSNumberResult;
          if (toJSNumberResult >= length) {
            do {
              tmp9 = f65967;
              multiplyResult = multiplyResult.multiply(f65967);
              tmp10 = length;
              diff = diff - (length - 1);
              obj3 = multiplyResult;
              tmp8 = diff;
            } while (diff >= length);
          }
          tmp11 = f65967;
          return obj3.multiply(f65967[tmp8]);
        }
      } else {
        _Error = Error;
        _String = String;
        str = " is too large for shifting.";
        tmp2 = new.target;
        tmp3 = new.target;
        error = new Error(String(toJSNumberResult) + " is too large for shifting.");
        tmp5 = error;
        throw error;
      }
    }
    shiftRight(arg0) {
      obj = parseValue(arg0);
      toJSNumberResult = obj.toJSNumber();
      if (Math.abs(toJSNumberResult) <= 10000000) {
        self = this;
        num = 0;
        if (toJSNumberResult < 0) {
          return self.shiftLeft(-toJSNumberResult);
        } else {
          tmp20 = length;
          num2 = 1;
          obj4 = self;
          diff = toJSNumberResult;
          tmp14 = self;
          tmp15 = toJSNumberResult;
          if (toJSNumberResult >= length) {
            tmp6 = obj4;
            tmp7 = diff;
            while (!obj4.isZero()) {
              if (!obj4.isNegative()) {
                tmp8 = divModAny;
                tmp9 = f65967;
                tmp10 = divModAny(obj4, f65967);
                [obj3, obj2] = tmp10;
                if (obj2.isNegative()) {
                  prevResult = obj3.prev();
                } else {
                  prevResult = obj3;
                }
                tmp12 = length;
                diff = diff - (length - 1);
                obj4 = prevResult;
                tmp14 = prevResult;
                tmp15 = diff;
              } else if (obj4.isUnit()) {
                break;
              }
              return obj4;
            }
          }
          tmp16 = divModAny;
          tmp17 = f65967;
          tmp18 = divModAny(tmp14, f65967[tmp15]);
          [obj6, obj5] = tmp18;
          if (obj5.isNegative()) {
            prevResult1 = obj6.prev();
          } else {
            prevResult1 = obj6;
          }
          return prevResult1;
        }
      } else {
        _Error = Error;
        _String = String;
        str = " is too large for shifting.";
        tmp2 = new.target;
        tmp3 = new.target;
        error = new Error(String(toJSNumberResult) + " is too large for shifting.");
        tmp5 = 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;
      tmp = Integer;
      self2 = this;
      if (this.compareTo(require("module_0")) < 0) {
        negateResult = self.negate();
        num = 1;
        self2 = negateResult.subtract(require("module_1"));
      }
      if (0 === self2.compareTo(require("module_0"))) {
        tmpResult = require("module_0");
      } else {
        num6 = 2;
        tmpResult1 = require("module_2");
        if (tmpResult1.compareTo(self2) <= 0) {
          squareResult = tmpResult1.square(tmpResult1);
          if (squareResult.compareTo(self2) <= 0) {
            tmp2 = integerLogarithm;
            tmp3 = integerLogarithm(self2, squareResult.square(squareResult));
            ({ p, e } = tmp3);
            multiplyResult = p.multiply(squareResult);
            if (multiplyResult.compareTo(self2) <= 0) {
              obj = { p: null, e: null };
              obj[0] = multiplyResult;
              num4 = 1;
              obj[1] = num6 * e + 1;
              obj1 = obj;
            } else {
              obj1 = { p: null, e: null };
              obj1[0] = p;
              obj1[1] = num6 * e;
            }
            tmp4 = obj1;
          } else {
            obj2 = { p: null, e: 0 };
            num3 = 1;
            obj2[0] = require("module_1");
            ({ p: p2, e: e2 } = obj2);
            multiplyResult1 = p2.multiply(tmpResult1);
            if (multiplyResult1.compareTo(self2) <= 0) {
              obj3 = { p: null, e: null };
              obj3[0] = multiplyResult1;
              num5 = 1;
              num6 = num6 * e2 + 1;
              obj3[1] = num6;
              obj4 = obj3;
            } else {
              obj4 = { p: null, e: null };
              obj4[0] = p2;
              obj4[1] = num6 * e2;
            }
            tmp5 = obj4;
          }
        } else {
          obj5 = { p: null, e: 0 };
          num2 = 1;
          obj5[0] = require("module_1");
          tmpResult2 = tmp(obj5.e);
          num7 = 1;
          tmpResult = tmpResult2.add(require("module_1"));
        }
      }
      return tmpResult;
    }
    toArray(arg0) {
      return toBase(this, arg0);
    }
    toString(arg0, arg1) {
      num = arg0;
      if (arg0 === undefined) {
        num = 10;
      }
      self = this;
      if (10 !== num) {
        tmp4 = arg1;
        closure_0 = arg1;
        tmp5 = toBase;
        num2 = 0;
        iter = toBase(self, num);
        str2 = "";
        str3 = "";
        if (iter.isNegative) {
          str3 = "-";
        }
        value = iter.value;
        mapped = value.map((arg0) => {
          let arr = closure_0;
          if (!closure_0) {
            arr = outer1_1;
          }
          if (arg0 < arr.length) {
            let text = arr[arg0];
          } else {
            text = `${"<" + arg0}>`;
          }
          return text;
        });
        return str3 + mapped.join("");
      } else {
        value1 = self.value;
        tmp6 = globalThis;
        _String2 = String;
        diff = value1.length - 1;
        StringResult = String(value1[diff]);
        diff1 = diff - 1;
        num3 = 0;
        str4 = "0000000";
        sum = StringResult;
        tmp3 = StringResult;
        if (diff1 >= 0) {
          do {
            _String = String;
            StringResult1 = String(value1[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);
    }
  }
  if (num >= 1000) {
    class Integer {
      constructor(arg0, arg1, arg2, arg3) {
        if (undefined === arg0) {
          tmp32 = Integer;
          first = Integer[0];
        } else {
          tmp33 = arg1;
          if (undefined !== arg1) {
            str = arg2;
            num = 10;
            if (10 === +arg1) {
            }
            tmp3 = parseBase;
            if (typeof parseBase !== "function") {
              str10 = "Trying to call a non-function";
              throwTypeErrorResult = HermesBuiltin.throwTypeError();
            }
            if (!str) {
              str = c1;
            }
            tmp4 = arg3;
            tmp5 = globalThis;
            _String = String;
            str2 = String(arg0);
            formatted1 = str;
            formatted = str2;
            if (!arg3) {
              formatted = str2.toLowerCase();
              formatted1 = str.toLowerCase();
            }
            length = formatted.length;
            _Math = Math;
            absolute = Math.abs(arg1);
            obj = {};
            num2 = 0;
            num3 = 1;
            num4 = 0;
            if (0 < formatted1.length) {
              do {
                obj[formatted1[num4]] = num4;
                num4 = num4 + 1;
                length2 = formatted1.length;
              } while (num4 < length2);
            }
            str3 = "1";
            str4 = "-";
            num5 = 0;
            if (0 < length) {
              while (true) {
                tmp7 = formatted[num5];
                tmp8 = num5;
                if ("-" !== tmp7) {
                  if (tmp7 in obj) {
                    if (obj[tmp7] >= absolute) {
                      if ("1" !== tmp7) {
                        break;
                      } else if (1 !== absolute) {
                        break;
                      }
                    }
                  }
                }
                num5 = num5 + 1;
              }
              _Error = Error;
              str5 = " is not a valid digit in base ";
              tmp9 = new.target;
              str6 = ".";
              tmp10 = new.target;
              error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
              tmp12 = error;
              throw error;
            }
            tmp13 = parseValue;
            tmp15 = "-" === formatted[0];
            num6 = 0;
            tmp14 = parseValue(arg1);
            if (tmp15) {
              num6 = 1;
            }
            items = [];
            str7 = "<";
            str8 = ">";
            if (num6 < formatted.length) {
              while (true) {
                tmp16 = formatted[num6];
                tmp17 = num6;
                if (tmp16 in obj) {
                  tmp26 = parseValue;
                  arr = items.push(parseValue(obj[tmp16]));
                  sum = num6;
                } else {
                  tmp18 = num6;
                  if ("<" !== tmp16) {
                    break;
                  } else {
                    sum = tmp18 + 1;
                    while (">" !== formatted[sum]) {
                      tmp18 = sum;
                      if (sum >= formatted.length) {
                        break;
                      }
                    }
                    tmp20 = parseValue;
                    arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                  }
                }
                num6 = sum + 1;
              }
              _Error2 = Error;
              str9 = " is not a valid character";
              tmp22 = new.target;
              tmp23 = new.target;
              error1 = new Error(tmp16 + " is not a valid character");
              tmp25 = error1;
              throw error1;
            }
            tmp28 = Integer;
            [tmp29, obj2] = Integer;
            diff = items.length - 1;
            addResult = tmp29;
            obj4 = tmp29;
            if (0 <= diff) {
              do {
                obj5 = items[diff];
                addResult = addResult.add(obj5.times(timesResult));
                timesResult = timesResult.times(tmp14);
                diff = diff - 1;
                obj4 = addResult;
              } while (0 <= diff);
            }
            negateResult = obj4;
            if (tmp15) {
              negateResult = obj4.negate();
            }
            first = negateResult;
          }
          tmp = parseValue;
          first = parseValue(arg0);
        }
        return first;
      }
    }
  } else {
    class Integer {
      constructor(arg0, arg1, arg2, arg3) {
        if (undefined === arg0) {
          tmp32 = Integer;
          first = Integer[0];
        } else {
          tmp33 = arg1;
          if (undefined !== arg1) {
            str = arg2;
            num = 10;
            if (10 === +arg1) {
            }
            tmp3 = parseBase;
            if (typeof parseBase !== "function") {
              str10 = "Trying to call a non-function";
              throwTypeErrorResult = HermesBuiltin.throwTypeError();
            }
            if (!str) {
              str = c1;
            }
            tmp4 = arg3;
            tmp5 = globalThis;
            _String = String;
            str2 = String(arg0);
            formatted1 = str;
            formatted = str2;
            if (!arg3) {
              formatted = str2.toLowerCase();
              formatted1 = str.toLowerCase();
            }
            length = formatted.length;
            _Math = Math;
            absolute = Math.abs(arg1);
            obj = {};
            num2 = 0;
            num3 = 1;
            num4 = 0;
            if (0 < formatted1.length) {
              do {
                obj[formatted1[num4]] = num4;
                num4 = num4 + 1;
                length2 = formatted1.length;
              } while (num4 < length2);
            }
            str3 = "1";
            str4 = "-";
            num5 = 0;
            if (0 < length) {
              while (true) {
                tmp7 = formatted[num5];
                tmp8 = num5;
                if ("-" !== tmp7) {
                  if (tmp7 in obj) {
                    if (obj[tmp7] >= absolute) {
                      if ("1" !== tmp7) {
                        break;
                      } else if (1 !== absolute) {
                        break;
                      }
                    }
                  }
                }
                num5 = num5 + 1;
              }
              _Error = Error;
              str5 = " is not a valid digit in base ";
              tmp9 = new.target;
              str6 = ".";
              tmp10 = new.target;
              error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
              tmp12 = error;
              throw error;
            }
            tmp13 = parseValue;
            tmp15 = "-" === formatted[0];
            num6 = 0;
            tmp14 = parseValue(arg1);
            if (tmp15) {
              num6 = 1;
            }
            items = [];
            str7 = "<";
            str8 = ">";
            if (num6 < formatted.length) {
              while (true) {
                tmp16 = formatted[num6];
                tmp17 = num6;
                if (tmp16 in obj) {
                  tmp26 = parseValue;
                  arr = items.push(parseValue(obj[tmp16]));
                  sum = num6;
                } else {
                  tmp18 = num6;
                  if ("<" !== tmp16) {
                    break;
                  } else {
                    sum = tmp18 + 1;
                    while (">" !== formatted[sum]) {
                      tmp18 = sum;
                      if (sum >= formatted.length) {
                        break;
                      }
                    }
                    tmp20 = parseValue;
                    arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                  }
                }
                num6 = sum + 1;
              }
              _Error2 = Error;
              str9 = " is not a valid character";
              tmp22 = new.target;
              tmp23 = new.target;
              error1 = new Error(tmp16 + " is not a valid character");
              tmp25 = error1;
              throw error1;
            }
            tmp28 = Integer;
            [tmp29, obj2] = Integer;
            diff = items.length - 1;
            addResult = tmp29;
            obj4 = tmp29;
            if (0 <= diff) {
              do {
                obj5 = items[diff];
                addResult = addResult.add(obj5.times(timesResult));
                timesResult = timesResult.times(tmp14);
                diff = diff - 1;
                obj4 = addResult;
              } while (0 <= diff);
            }
            negateResult = obj4;
            if (tmp15) {
              negateResult = obj4.negate();
            }
            first = negateResult;
          }
          tmp = parseValue;
          first = parseValue(arg0);
        }
        return first;
      }
    }
  }
}
[Integer.zero, Integer.one] = Integer;
Integer.minusOne = Integer[-1];
Integer.max = function max(arg0, arg1) {
  const obj = parseValue(arg0);
  let tmp = parseValue(arg1);
  if (obj.greater(tmp)) {
    tmp = obj;
  }
  return tmp;
};
Integer.min = function min(arg0, arg1) {
  const obj = parseValue(arg0);
  let tmp = parseValue(arg1);
  if (obj.lesser(tmp)) {
    tmp = obj;
  }
  return tmp;
};
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, absResult1, arg2) {
  let random = arg2;
  const tmp2 = parseValue(arg0);
  const tmp3 = parseValue(absResult1);
  if (!arg2) {
    const _Math = Math;
    random = Math.random;
  }
  let tmpResult = tmp(tmp2);
  tmpResult = tmp(tmp3);
  const tmpResult1 = parseValue(tmp2);
  let tmpResult2 = tmp(tmp3);
  if (tmpResult1.greater(tmpResult2)) {
    tmpResult2 = tmpResult1;
  }
  const addResult = tmpResult2.subtract(tmpResult).add(1);
  if (addResult.isSmall) {
    const _Math4 = Math;
    return tmpResult.add(Math.floor(random() * addResult));
  } else {
    const value = toBase(addResult, 10000000).value;
    const items = [];
    let num3 = 0;
    let flag2 = true;
    if (0 < value.length) {
      do {
        let tmp8 = num3;
        let flag3 = flag2;
        let num4 = 10000000;
        if (flag2) {
          num4 = value[num3];
        }
        let result = random() * num4;
        if (result > 0) {
          let _Math3 = Math;
          let rounded = Math.floor(result);
        } else {
          let _Math2 = Math;
          rounded = Math.ceil(result);
        }
        let arr = items.push(rounded);
        if (rounded < num4) {
          flag3 = false;
        }
        num3 = num3 + 1;
        flag2 = flag3;
      } while (num3 < value.length);
    }
    return tmpResult.add(Integer.fromArray(items, 10000000, false));
  }
  const subtractResult = tmpResult2.subtract(tmpResult);
};
Integer.fromArray = (arr) => {
  let obj;
  let tmp2;
  const mapped = arr.map(parseValue);
  [tmp2, obj] = Integer;
  let diff = mapped.length - 1;
  let addResult = tmp2;
  let obj3 = tmp2;
  if (0 <= diff) {
    do {
      let obj4 = mapped[diff];
      addResult = addResult.add(obj4.times(timesResult));
      timesResult = timesResult.times(tmp);
      diff = diff - 1;
      obj3 = addResult;
    } while (0 <= diff);
  }
  let negateResult = obj3;
  if (arg2) {
    negateResult = obj3.negate();
  }
  return negateResult;
};
let hasOwnPropertyResult = undefined !== arg4;
if (hasOwnPropertyResult) {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
  hasOwnPropertyResult = arg4.hasOwnProperty("exports");
}
if (hasOwnPropertyResult) {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
}
let amd = typeof globalThis.define === "function";
if (typeof globalThis.define === "function") {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
  amd = globalThis.define.amd;
}
if (amd) {
  class Integer {
    constructor(arg0, arg1, arg2, arg3) {
      if (undefined === arg0) {
        tmp32 = Integer;
        first = Integer[0];
      } else {
        tmp33 = arg1;
        if (undefined !== arg1) {
          str = arg2;
          num = 10;
          if (10 === +arg1) {
          }
          tmp3 = parseBase;
          if (typeof parseBase !== "function") {
            str10 = "Trying to call a non-function";
            throwTypeErrorResult = HermesBuiltin.throwTypeError();
          }
          if (!str) {
            str = c1;
          }
          tmp4 = arg3;
          tmp5 = globalThis;
          _String = String;
          str2 = String(arg0);
          formatted1 = str;
          formatted = str2;
          if (!arg3) {
            formatted = str2.toLowerCase();
            formatted1 = str.toLowerCase();
          }
          length = formatted.length;
          _Math = Math;
          absolute = Math.abs(arg1);
          obj = {};
          num2 = 0;
          num3 = 1;
          num4 = 0;
          if (0 < formatted1.length) {
            do {
              obj[formatted1[num4]] = num4;
              num4 = num4 + 1;
              length2 = formatted1.length;
            } while (num4 < length2);
          }
          str3 = "1";
          str4 = "-";
          num5 = 0;
          if (0 < length) {
            while (true) {
              tmp7 = formatted[num5];
              tmp8 = num5;
              if ("-" !== tmp7) {
                if (tmp7 in obj) {
                  if (obj[tmp7] >= absolute) {
                    if ("1" !== tmp7) {
                      break;
                    } else if (1 !== absolute) {
                      break;
                    }
                  }
                }
              }
              num5 = num5 + 1;
            }
            _Error = Error;
            str5 = " is not a valid digit in base ";
            tmp9 = new.target;
            str6 = ".";
            tmp10 = new.target;
            error = new Error(tmp7 + " is not a valid digit in base " + arg1 + ".");
            tmp12 = error;
            throw error;
          }
          tmp13 = parseValue;
          tmp15 = "-" === formatted[0];
          num6 = 0;
          tmp14 = parseValue(arg1);
          if (tmp15) {
            num6 = 1;
          }
          items = [];
          str7 = "<";
          str8 = ">";
          if (num6 < formatted.length) {
            while (true) {
              tmp16 = formatted[num6];
              tmp17 = num6;
              if (tmp16 in obj) {
                tmp26 = parseValue;
                arr = items.push(parseValue(obj[tmp16]));
                sum = num6;
              } else {
                tmp18 = num6;
                if ("<" !== tmp16) {
                  break;
                } else {
                  sum = tmp18 + 1;
                  while (">" !== formatted[sum]) {
                    tmp18 = sum;
                    if (sum >= formatted.length) {
                      break;
                    }
                  }
                  tmp20 = parseValue;
                  arr1 = items.push(parseValue(formatted.slice(num6 + 1, sum)));
                }
              }
              num6 = sum + 1;
            }
            _Error2 = Error;
            str9 = " is not a valid character";
            tmp22 = new.target;
            tmp23 = new.target;
            error1 = new Error(tmp16 + " is not a valid character");
            tmp25 = error1;
            throw error1;
          }
          tmp28 = Integer;
          [tmp29, obj2] = Integer;
          diff = items.length - 1;
          addResult = tmp29;
          obj4 = tmp29;
          if (0 <= diff) {
            do {
              obj5 = items[diff];
              addResult = addResult.add(obj5.times(timesResult));
              timesResult = timesResult.times(tmp14);
              diff = diff - 1;
              obj4 = addResult;
            } while (0 <= diff);
          }
          negateResult = obj4;
          if (tmp15) {
            negateResult = obj4.negate();
          }
          first = negateResult;
        }
        tmp = parseValue;
        first = parseValue(arg0);
      }
      return first;
    }
  }
  globalThis.define(() => Integer);
}