fn pub static parse[T: Bytes](
  bytes: ref T,
  format: ref Format,
) -> Option[Int] {
  let base = format.to_base
  let len = bytes.size
  let mut idx = 0
  let pos = match bytes.get(idx) {
    case Ok(PLUS) -> {
      idx += 1

      if idx == len { return Option.None } else { true }
    }
    case Ok(MINUS) -> {
      idx += 1

      if idx == len { return Option.None } else { false }
    }
    case Ok(_) -> true
    case _ -> return Option.None
  }

  let mut num = 0

  # For base 16 numbers, we allow them to start with -0x and 0x, as most base
  # 16 numbers will likely use the format 0xABC and not just ABC.
  if base == 16 and bytes.get(idx).or(-1) == ZERO {
    match bytes.get(idx + 1) {
      case Ok(LOWER_X) -> {
        idx += 2

        if idx == len { return Option.None }
      }
      case _ -> {}
    }
  }

  # Rust's approach is to check if an overflow is possible, and use wrapped
  # arithmetic in that case, in an attempt to improve performance. This was
  # implemented in https://github.com/rust-lang/rust/pull/95399, with
  # https://github.com/rust-lang/rust/pull/83371 and
  # https://github.com/rust-lang/rust/pull/83088 being related pull requests.
  #
  # I opted not to take this approach at the time of writing, as the
  # performance improvements seem very small, and simply not worth the extra
  # code at the time of writing. If this ever changes, we can consider taking
  # a similar approach.
  while idx < len {
    let digit = match bytes.get(idx).or_panic {
      case v if digit?(v) -> v - ZERO
      case v if v >= LOWER_A and v <= LOWER_F -> v - LOWER_A + 10
      case v if v >= UPPER_A and v <= UPPER_F -> v - UPPER_A + 10
      case _ -> return Option.None
    }

    if digit > base or digit < 0 { return Option.None }

    num = try num.checked_mul(base)
    num = try if pos {
      num.checked_add(digit)
    } else {
      num.checked_sub(digit)
    }

    idx += 1
  }

  Option.Some(num)
}

fn pub static sum[I: Iter[Int]](iterator: move I) -> Int {
  iterator.reduce(0, fn (acc, val) { acc + val })
}

fn pub inline !=(other: ref Int) -> Bool {
  _INKO.int_ne(self, other)
}

fn pub inline %(other: Int) -> Int {
  mode.mod(self, other)
}

fn pub inline &(other: ref Int) -> Int {
  _INKO.int_bit_and(self, other)
}

fn pub inline *(other: Int) -> Int {
  mode.mul(self, other)
}

fn pub inline **(other: ref Int) -> Int {
  mode.pow(self, other)
}

fn pub inline +(other: Int) -> Int {
  mode.add(self, other)
}

fn pub inline -(other: Int) -> Int {
  mode.sub(self, other)
}

fn pub inline /(other: ref Int) -> Int {
  if other == 0 or (self == MIN and other == -1) { overflow_error }

  unchecked_div(other)
}

fn pub inline <(other: ref Int) -> Bool {
  _INKO.int_lt(self, other)
}

fn pub inline <<(other: Int) -> Int {
  mode.shl(self, other)
}

fn pub inline <=(other: ref Int) -> Bool {
  _INKO.int_le(self, other)
}

fn pub inline ==(other: ref Int) -> Bool {
  _INKO.int_eq(self, other)
}

fn pub inline >(other: ref Int) -> Bool {
  _INKO.int_gt(self, other)
}

fn pub inline >=(other: ref Int) -> Bool {
  _INKO.int_ge(self, other)
}

fn pub inline >>(other: Int) -> Int {
  mode.shr(self, other)
}

fn pub inline >>>(other: Int) -> Int {
  mode.ushr(self, other)
}

fn pub inline ^(other: ref Int) -> Int {
  _INKO.int_bit_xor(self, other)
}

fn pub inline absolute -> Int {
  _INKO.int_absolute(self)
}

fn pub inline checked_add(other: Int) -> Option[Int] {
  let res = _INKO.int_checked_add(self, other)

  if res.tag as Int == 0 {
    Option.Some(res.value as Int)
  } else {
    Option.None
  }
}

fn pub inline checked_div(other: Int) -> Option[Int] {
  if other == 0 or (self == MIN and other == -1) {
    Option.None
  } else {
    Option.Some(unchecked_div(other))
  }
}

fn pub inline checked_mul(other: Int) -> Option[Int] {
  let res = _INKO.int_checked_mul(self, other)

  if res.tag as Int == 0 {
    Option.Some(res.value as Int)
  } else {
    Option.None
  }
}

fn pub inline checked_pow(other: Int) -> Option[Int] {
  let res = inko_int_checked_pow(self, other)

  if res.tag as Int == 0 {
    Option.Some(res.value as Int)
  } else {
    Option.None
  }
}

fn pub inline checked_sub(other: Int) -> Option[Int] {
  let res = _INKO.int_checked_sub(self, other)

  if res.tag as Int == 0 {
    Option.Some(res.value as Int)
  } else {
    Option.None
  }
}

fn pub inline clone -> Int {
  self
}

fn pub inline cmp(other: ref Int) -> Ordering {
  if self > other {
    Ordering.Greater
  } else if self < other {
    Ordering.Less
  } else {
    Ordering.Equal
  }
}

fn pub digits -> Int {
  if self == 0 { return 1 }

  let mut digits = 0
  let mut number = absolute

  while number > 0 {
    number /= 10
    digits += 1
  }

  digits
}

fn pub fmt(formatter: mut Formatter) {
  formatter.write(to_string)
}

fn pub format(format: ref Format) -> String {
  let base = format.to_base

  match self {
    case 0 -> return '0'
    # MIN can't be turned positive using absolute(), so we have to handle
    # these cases explicitly.
    case MIN if base == 2 -> {
      return '-1000000000000000000000000000000000000000000000000000000000000000'
    }
    case MIN if base == 10 -> return '-9223372036854775808'
    case MIN if base == 16 -> return '-8000000000000000'
    case _ -> {}
  }

  let alphabet = '0123456789abcdef'
  let bytes = ByteArray.new
  let mut int = absolute

  while int > 0 {
    bytes.push(alphabet.get(int % base).or_panic)
    int /= base
  }

  if self < 0 { bytes.push(0x2D) }

  bytes.reverse
  bytes.into_string
}

fn pub inline hash[H: mut + Hasher](hasher: mut H) {
  hasher.write(clone)
}

fn pub inline leading_ones -> Int {
  _INKO.int_leading_zeros(not)
}

fn pub inline leading_zeros -> Int {
  _INKO.int_leading_zeros(self)
}

fn pub nearest_power_of_two -> Int {
  if self <= 0 { return 0 }

  let mut rounded = clone

  rounded -= 1
  rounded |= rounded >> 1
  rounded |= rounded >> 2
  rounded |= rounded >> 4
  rounded |= rounded >> 8
  rounded |= rounded >> 16
  rounded |= rounded >> 32
  rounded += 1

  rounded
}

fn pub inline not -> Int {
  _INKO.int_bit_not(self)
}

fn pub inline opposite -> Int {
  0 - self
}

fn pub inline rotate_left(amount: Int) -> Int {
  _INKO.int_rotate_left(self, amount)
}

fn pub inline rotate_right(amount: Int) -> Int {
  _INKO.int_rotate_right(self, amount)
}

fn pub inline swap_bytes -> Int {
  _INKO.int_swap_bytes(self)
}

fn pub times(block: fn (Int)) {
  let mut index = 0

  while index < self {
    block.call(index)

    index += 1
  }
}

fn pub inline to(other: Int) -> InclusiveRange {
  InclusiveRange.new(clone, other)
}

fn pub inline to_float -> Float {
  self as Float
}

fn pub inline to_int -> Int {
  clone
}

fn pub to_string -> String {
  format(Format.Decimal)
}

fn pub inline trailing_ones -> Int {
  _INKO.int_trailing_zeros(not)
}

fn pub inline trailing_zeros -> Int {
  _INKO.int_trailing_zeros(self)
}

fn pub inline until(other: Int) -> ExclusiveRange {
  ExclusiveRange.new(clone, other)
}

fn pub inline wrapping_add(other: Int) -> Int {
  _INKO.int_wrapping_add(self, other)
}

fn pub inline wrapping_mul(other: Int) -> Int {
  _INKO.int_wrapping_mul(self, other)
}

fn pub inline wrapping_sub(other: Int) -> Int {
  _INKO.int_wrapping_sub(self, other)
}

fn pub inline |(other: ref Int) -> Int {
  _INKO.int_bit_or(self, other)
}