class Integer

def self.sqrt(n)
  n = Backports.coerce_to_int(n)
  return Math.sqrt(n).to_i if n <= 9_999_899_999_899_999_322_536_673_279
  bits_shift = n.bit_length / 2 + 1
  bitn_mask = root = 1 << bits_shift
  loop do
    root ^= bitn_mask if (root * root) > n
    bitn_mask >>= 1
    return root if bitn_mask == 0
    root |= bitn_mask
  end
end

def self.try_convert(obj)
  ::Backports.try_convert(obj, ::Integer, :to_int)
end

def allbits?(n)
  n = Backports.coerce_to_int(n)
  n & self == n
end

def anybits?(n)
  n = Backports.coerce_to_int(n)
  n & self != 0
end

def ceildiv(arg)
  fdiv(arg).ceil
end

def even?
  self[0].zero?
end

def nobits?(n)
  n = Backports.coerce_to_int(n)
  n & self == 0
end

def odd?
  !self[0].zero?
end

def ord
  self
end

def pred
  self - 1
end

def prime?
  return self >= 2 if self <= 3
  return false if self % 2 == 0 or self % 3 == 0
  (5..(self**0.5).floor).step(6).each do |i|
    if self % i == 0 || self % (i + 2) == 0
      return false
    end
  end
  true
end

def prime_division(generator = Prime::Generator23.new)
  Prime.prime_division(self, generator)
end

def round_with_digits(ndigits=0)
  ndigits = Backports::coerce_to_int(ndigits)
  case
  when ndigits.zero?
    self
  when ndigits > 0
    raise RangeError if ndigits >= 1<<31
    Float(self)
  else
    pow = 10 ** (-ndigits)
    return 0 if pow.is_a?(Float) # when ndigits hugely negative
    remain = self % pow
    comp = self < 0 ? :<= : :<
    remain -= pow unless remain.send(comp, pow / 2)
    self - remain
  end
end