fn pub static parse[T: Bytes](
  bytes: ref T,
  format: ref Format,
) -> Option[Int] {
  let input = bytes.bytes.peekable
  let base = format.to_base
  let mut byte = -1
  let pos = match input.next {
    case Some(PLUS) -> {
      byte = try input.next
      true
    }
    case Some(MINUS) -> {
      byte = try input.next
      false
    }
    case Some(val) -> {
      byte = val
      true
    }
    case None -> 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 byte == ZERO {
    match input.peek {
      case Some(LOWER_X) -> {
        input.next
        byte = try input.next
      }
      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.
  loop {
    let digit = if base <= 10 {
      byte.wrapping_sub(ZERO)
    } else if byte >= ZERO and byte <= NINE {
      byte - ZERO
    } else if byte >= LOWER_A and byte <= LOWER_F {
      byte - LOWER_A + 10
    } else if byte >= UPPER_A and byte <= UPPER_F {
      byte - UPPER_A + 10
    } else {
      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)
    }

    match input.next {
      case Some(val) -> byte = val
      case _ -> return Option.Some(num)
    }
  }
}

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

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub %(other: ref Int) -> Int {
  if other == 0 or (self == MIN and other == -1) {
    overflow(self, '%', other)
  }

  let sum = _INKO.int_checked_add(_INKO.int_rem(self, other), other)

  if sum.tag as Int == 0 {
    _INKO.int_rem(sum.value as Int, other)
  } else {
    overflow(self, '%', other)
  }
}

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

fn pub *(other: ref Int) -> Int {
  let res = _INKO.int_checked_mul(self, other)

  if res.tag as Int == 0 {
    res.value as Int
  } else {
    overflow(self, '*', other)
  }
}

fn pub **(other: ref Int) -> Int {
  let res = inko_int_checked_pow(self, other)

  if res.tag as Int == 0 {
    res.value as Int
  } else {
    overflow(self, '**', other)
  }
}

fn pub +(other: ref Int) -> Int {
  let res = _INKO.int_checked_add(self, other)

  if res.tag as Int == 0 {
    res.value as Int
  } else {
    overflow(self, '+', other)
  }
}

fn pub -(other: ref Int) -> Int {
  let res = _INKO.int_checked_sub(self, other)

  if res.tag as Int == 0 {
    res.value as Int
  } else {
    overflow(self, '-', other)
  }
}

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

  unchecked_div(other)
}

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

fn pub <<(other: ref Int) -> Int {
  if other >= BITS { overflow(self, '<<', other) }

  _INKO.int_shl(self, other)
}

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

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

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

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

fn pub >>(other: ref Int) -> Int {
  if other >= BITS { overflow(self, '>>', other) }

  _INKO.int_shr(self, other)
}

fn pub >>>(other: ref Int) -> Int {
  if other >= BITS { overflow(self, '>>>', other) }

  _INKO.int_unsigned_shr(self, other)
}

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

fn pub absolute -> Int {
  if self < 0 { 0 - self } else { clone }
}

fn pub 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 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 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 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 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 clone -> Int {
  self
}

fn pub 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.byte(int % base))
    int /= base
  }

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

  bytes.reverse
  bytes.into_string
}

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

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 not -> Int {
  _INKO.int_bit_not(self)
}

fn pub opposite -> Int {
  0 - self
}

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

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

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

  while index < self {
    block.call(index)

    index += 1
  }
}

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

fn pub to_float -> Float {
  self as Float
}

fn pub to_int -> Int {
  clone
}

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

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

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

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

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

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