Integer square root without a library

def my_sqrt(x):
    lo, hi = 0, x                      # the answer is in [lo, hi]
    while lo < hi:
        mid = (lo + hi + 1) // 2       # round up, or lo = mid never moves
        if mid * mid <= x:
            lo = mid                   # mid works; the answer is mid or larger
        else:
            hi = mid - 1
    return lo

long long solve(long long x) {
    long long lo = 0, hi = x;              // the answer is in [lo, hi]
    while (lo < hi) {
        long long mid = lo + (hi - lo + 1) / 2;   // round up, or lo = mid never moves
        if (mid * mid <= x) lo = mid;      // 64-bit: mid < 2^31, so mid * mid < 2^62
        else hi = mid - 1;
    }
    return lo;
}

class Solution {
    public int mySqrt(int x) {
        long lo = 0, hi = x;                   // the answer is in [lo, hi]
        while (lo < hi) {
            long mid = lo + (hi - lo + 1) / 2; // round up, or lo = mid never moves
            if (mid * mid <= x) lo = mid;      // long: no overflow
            else hi = mid - 1;
        }
        return (int) lo;
    }
}

function mySqrt(x) {
  let lo = 0, hi = x;                    // the answer is in [lo, hi]
  while (lo < hi) {
    const mid = lo + Math.ceil((hi - lo) / 2);   // round up
    if (mid * mid <= x) lo = mid;        // exact wherever it matters: near x the square is below 2^32
    else hi = mid - 1;
  }
  return lo;
}

fn solve(x: i64) -> i64 {
    let (mut lo, mut hi) = (0i64, x);      // the answer is in [lo, hi]
    while lo < hi {
        let mid = lo + (hi - lo + 1) / 2;  // round up, or lo = mid never moves
        if mid * mid <= x { lo = mid } else { hi = mid - 1 }
    }
    lo
}

solve :: Int -> Int
solve x = go 0 x
  where
    -- the answer is in [lo, hi]; mid rounds up so that lo = mid always moves
    go lo hi
      | lo >= hi        = lo
      | mid * mid <= x  = go mid hi
      | otherwise       = go lo (mid - 1)
      where mid = lo + (hi - lo + 1) `div` 2