lean-python 0.1.0__py3-none-any.whl

lean_python/runtime.py

@@ -0,0 +1,1400 @@
+"""Runtime of the Python code generated by lean-python.
+
+The functions named ``lean_*`` (and the libm names) are the C names of Lean's externs and
+follow ``lean.h``: arguments marked borrowed there are not consumed, results are owned.
+
+Values:
+
+- ``Nat``, ``Int``, boxed scalars and fixed-width integers are ``int``; ``Float`` and
+  ``Float32`` are ``float``; ``String`` is ``bytes`` holding UTF-8.
+- A constructor without fields is its tag (an ``int``); other constructors are ``Ctor``.
+- ``Array``, ``ByteArray`` and ``FloatArray`` are ``LArray``, ``LByteArray``, ``LFloatArray``.
+- ``Ctor`` and the arrays carry a reference count ``rc``, maintained by the ``inc``/``dec``
+  instructions of the IR, so updates of uniquely referenced values happen in place as in C.
+  Closures, thunks, tasks and references do not carry one: values read out of them are
+  always counted as shared.
+"""
+
+import importlib
+import math
+import struct
+import sys
+
+PERSISTENT = 1 << 62
+
+sys.setrecursionlimit(1_000_000)
+
+
+class Ctor:
+    __slots__ = ("objs", "rc", "sc", "tag")
+
+    def __init__(self, tag, objs):
+        self.tag = tag
+        self.rc = 1
+        self.objs = objs
+        self.sc = {}
+
+    def __repr__(self):
+        return f"Ctor({self.tag}, {self.objs!r}, {self.sc!r})"
+
+
+class LArray:
+    __slots__ = ("data", "rc")
+
+    def __init__(self, data):
+        self.rc = 1
+        self.data = data
+
+    def __repr__(self):
+        return f"LArray({self.data!r})"
+
+
+class LByteArray:
+    __slots__ = ("data", "rc")
+
+    def __init__(self, data):
+        self.rc = 1
+        self.data = data
+
+
+class LFloatArray:
+    __slots__ = ("data", "rc")
+
+    def __init__(self, data):
+        self.rc = 1
+        self.data = data
+
+
+class Closure:
+    __slots__ = ("arity", "fixed", "fn")
+
+    def __init__(self, fn, arity, fixed):
+        self.fn = fn
+        self.arity = arity
+        self.fixed = fixed
+
+
+class Thunk:
+    __slots__ = ("done", "fn", "value")
+
+    def __init__(self, fn, value=None, done=False):
+        self.fn = fn
+        self.value = value
+        self.done = done
+
+
+class Task:
+    __slots__ = ("value",)
+
+    def __init__(self, value):
+        self.value = value
+
+
+class Ref:
+    __slots__ = ("value",)
+
+    def __init__(self, value):
+        self.value = value
+
+
+_RC = (Ctor, LArray, LByteArray, LFloatArray)
+
+# Classes of external objects with a reference count, and what to do when it reaches 0.
+_FINALIZERS = {}
+
+
+def register_external(cls, finalize):
+    global _RC
+    _RC = (*_RC, cls)
+    _FINALIZERS[cls] = finalize
+
+
+# ---------------------------------------------------------------------------
+# Reference counting
+
+
+def lean_inc(x):
+    if x.__class__ in _RC:
+        x.rc += 1
+
+
+def lean_inc_n(x, n):
+    if x.__class__ in _RC:
+        x.rc += n
+
+
+def lean_inc_ret(x):
+    if x.__class__ in _RC:
+        x.rc += 1
+    return x
+
+
+def lean_dec(x):
+    if x.__class__ in _RC:
+        x.rc -= 1
+        if x.rc == 0:
+            _free(x)
+
+
+def _free(x):
+    stack = [x]
+    while stack:
+        o = stack.pop()
+        if o.__class__ is Ctor:
+            children = o.objs
+        elif o.__class__ is LArray:
+            children = o.data
+        else:
+            fin = _FINALIZERS.get(o.__class__)
+            if fin is not None:
+                fin(o)
+            continue
+        for c in children:
+            if c.__class__ in _RC:
+                c.rc -= 1
+                if c.rc == 0:
+                    stack.append(c)
+
+
+def lean_is_exclusive(x):
+    return x.__class__ in _RC and x.rc == 1
+
+
+def lean_is_shared(x):
+    return not (x.__class__ in _RC and x.rc == 1)
+
+
+def lean_mark_persistent(x):
+    stack = [x]
+    while stack:
+        o = stack.pop()
+        if o.__class__ is Ctor:
+            if o.rc != PERSISTENT:
+                o.rc = PERSISTENT
+                stack.extend(o.objs)
+        elif o.__class__ is LArray:
+            if o.rc != PERSISTENT:
+                o.rc = PERSISTENT
+                stack.extend(o.data)
+        elif o.__class__ in _RC:
+            o.rc = PERSISTENT
+    return x
+
+
+def lean_obj_tag(x):
+    if isinstance(x, int):
+        return x
+    return x.tag
+
+
+def lean_reset(y, n):
+    if y.__class__ is Ctor and y.rc == 1:
+        objs = y.objs
+        for i in range(n):
+            lean_dec(objs[i])
+        return y
+    lean_dec(y)
+    return 0
+
+
+def lean_reuse(y, tag, upd, objs):
+    if isinstance(y, int):
+        return Ctor(tag, objs)
+    y.objs = objs
+    if upd:
+        y.tag = tag
+    return y
+
+
+# ---------------------------------------------------------------------------
+# Panics
+
+
+def _eprint(msg):
+    sys.stdout.flush()
+    sys.stderr.write(msg + "\n")
+    sys.stderr.flush()
+
+
+def _panic(msg):
+    _eprint(msg)
+
+
+def lean_panic_fn(default, msg):
+    _panic(_s(msg))
+    return default
+
+
+def lean_panic_fn_borrowed(default, msg):
+    lean_inc(default)
+    _panic(_s(msg))
+    return default
+
+
+def lean_internal_panic(msg):
+    _eprint(f"INTERNAL PANIC: {msg}")
+    sys.exit(1)
+
+
+def lean_internal_panic_unreachable():
+    lean_internal_panic("unreachable code has been reached")
+
+
+def lean_dbg_trace(msg, fn):
+    _eprint(_s(msg))
+    return lean_apply(fn, [0])
+
+
+def lean_dbg_trace_if_shared(s, a):
+    if lean_is_shared(a):
+        _eprint(f"shared RC {_s(s)}")
+    return a
+
+
+# ---------------------------------------------------------------------------
+# Closures
+
+
+def lean_apply(f, args):
+    while True:
+        fixed = f.fixed
+        for a in fixed:
+            lean_inc(a)
+        need = f.arity - len(fixed)
+        n = len(args)
+        if n < need:
+            return Closure(f.fn, f.arity, fixed + args)
+        if n == need:
+            return f.fn(*fixed, *args)
+        r = f.fn(*fixed, *args[:need])
+        args = args[need:]
+        f = r
+
+
+def lean_py_extern(module, attr):
+    return getattr(importlib.import_module(module), attr)
+
+
+# ---------------------------------------------------------------------------
+# Lists
+
+
+def _list_to_py(xs):
+    out = []
+    while xs.__class__ is Ctor:
+        out.append(xs.objs[0])
+        xs = xs.objs[1]
+    return out
+
+
+def _py_to_list(items):
+    r = 0
+    for x in reversed(items):
+        r = Ctor(1, [x, r])
+    return r
+
+
+# ---------------------------------------------------------------------------
+# Nat and Int
+
+
+def lean_nat_add(a, b):
+    return a + b
+
+
+def lean_nat_sub(a, b):
+    return a - b if a > b else 0
+
+
+def lean_nat_mul(a, b):
+    return a * b
+
+
+def lean_nat_div(a, b):
+    return a // b if b else 0
+
+
+def lean_nat_mod(a, b):
+    return a % b if b else a
+
+
+def lean_nat_pow(a, b):
+    return a**b
+
+
+def lean_nat_gcd(a, b):
+    return math.gcd(a, b)
+
+
+def lean_nat_lcm(a, b):
+    return math.lcm(a, b)
+
+
+def lean_nat_log2(a):
+    return a.bit_length() - 1 if a > 0 else 0
+
+
+def lean_nat_land(a, b):
+    return a & b
+
+
+def lean_nat_lor(a, b):
+    return a | b
+
+
+def lean_nat_lxor(a, b):
+    return a ^ b
+
+
+def lean_nat_shiftl(a, b):
+    return a << b
+
+
+def lean_nat_shiftr(a, b):
+    return a >> b
+
+
+def lean_nat_dec_eq(a, b):
+    return a == b
+
+
+def lean_nat_dec_lt(a, b):
+    return a < b
+
+
+def lean_nat_dec_le(a, b):
+    return a <= b
+
+
+def lean_nat_pred(a):
+    return a - 1 if a > 0 else 0
+
+
+def lean_nat_succ(a):
+    return a + 1
+
+
+def lean_nat_to_int(a):
+    return a
+
+
+def lean_nat_abs(a):
+    return -a if a < 0 else a
+
+
+def lean_int_neg_succ_of_nat(a):
+    return -a - 1
+
+
+def lean_int_to_nat(a):
+    return max(0, a)
+
+
+def lean_int_neg(a):
+    return -a
+
+
+def lean_int_add(a, b):
+    return a + b
+
+
+def lean_int_sub(a, b):
+    return a - b
+
+
+def lean_int_mul(a, b):
+    return a * b
+
+
+def lean_int_div(a, b):
+    if b == 0:
+        return 0
+    q = abs(a) // abs(b)
+    return q if (a < 0) == (b < 0) else -q
+
+
+def lean_int_mod(a, b):
+    if b == 0:
+        return a
+    r = abs(a) % abs(b)
+    return -r if a < 0 else r
+
+
+def lean_int_ediv(a, b):
+    if b == 0:
+        return 0
+    r = a % abs(b)
+    return (a - r) // b
+
+
+def lean_int_emod(a, b):
+    if b == 0:
+        return a
+    return a % abs(b)
+
+
+def lean_int_dec_eq(a, b):
+    return a == b
+
+
+def lean_int_dec_lt(a, b):
+    return a < b
+
+
+def lean_int_dec_le(a, b):
+    return a <= b
+
+
+def lean_int_dec_nonneg(a):
+    return a >= 0
+
+
+def lean_int_pow(a, b):
+    return a**b
+
+
+def lean_int_land(a, b):
+    return a & b
+
+
+def lean_int_lor(a, b):
+    return a | b
+
+
+def lean_int_xor(a, b):
+    return a ^ b
+
+
+def lean_int_shift_right(a, b):
+    return a >> b
+
+
+def lean_cstr_to_nat(s):
+    return int(s)
+
+
+def lean_big_usize_to_nat(a):
+    return a
+
+
+def lean_usize_to_nat(a):
+    return a
+
+
+def lean_unsigned_to_nat(a):
+    return a
+
+
+def lean_system_platform_nbits(_unit=0):
+    return 64
+
+
+# ---------------------------------------------------------------------------
+# Fixed-width integers
+
+_WIDTHS = {"uint8": 8, "uint16": 16, "uint32": 32, "uint64": 64, "usize": 64}
+
+
+def _define_uint(name, bits):
+    mask = (1 << bits) - 1
+    g = globals()
+    g[f"lean_{name}_of_nat"] = lambda a: a & mask
+    g[f"lean_{name}_of_nat_mk"] = lambda a: a & mask
+    g[f"lean_{name}_to_nat"] = lambda a: a
+    g[f"lean_{name}_add"] = lambda a, b: (a + b) & mask
+    g[f"lean_{name}_sub"] = lambda a, b: (a - b) & mask
+    g[f"lean_{name}_mul"] = lambda a, b: (a * b) & mask
+    g[f"lean_{name}_div"] = lambda a, b: a // b if b else 0
+    g[f"lean_{name}_mod"] = lambda a, b: a % b if b else a
+    g[f"lean_{name}_land"] = lambda a, b: a & b
+    g[f"lean_{name}_lor"] = lambda a, b: a | b
+    g[f"lean_{name}_xor"] = lambda a, b: a ^ b
+    g[f"lean_{name}_shift_left"] = lambda a, b: (a << (b % bits)) & mask
+    g[f"lean_{name}_shift_right"] = lambda a, b: a >> (b % bits)
+    g[f"lean_{name}_complement"] = lambda a: a ^ mask
+    g[f"lean_{name}_neg"] = lambda a: (-a) & mask
+    g[f"lean_{name}_log2"] = lambda a: a.bit_length() - 1 if a > 0 else 0
+    g[f"lean_{name}_dec_eq"] = lambda a, b: a == b
+    g[f"lean_{name}_dec_lt"] = lambda a, b: a < b
+    g[f"lean_{name}_dec_le"] = lambda a, b: a <= b
+    g[f"lean_{name}_to_float"] = lambda a: float(a)
+    g[f"lean_{name}_to_float32"] = lambda a: _f32(float(a))
+    for other, obits in _WIDTHS.items():
+        if other != name:
+            omask = (1 << obits) - 1
+            g[f"lean_{name}_to_{other}"] = lambda a, omask=omask: a & omask
+
+
+for _n, _b in _WIDTHS.items():
+    _define_uint(_n, _b)
+
+
+_SWIDTHS = {"int8": 8, "int16": 16, "int32": 32, "int64": 64, "isize": 64}
+
+
+def _define_sint(name, bits):
+    mask = (1 << bits) - 1
+    half = 1 << (bits - 1)
+
+    def val(a):
+        return a - (1 << bits) if a >= half else a
+
+    g = globals()
+    g[f"lean_{name}_of_int"] = lambda a: a & mask
+    g[f"lean_{name}_of_nat"] = lambda a: a & mask
+    g[f"lean_{name}_to_int"] = val
+    g[f"lean_{name}_add"] = lambda a, b: (a + b) & mask
+    g[f"lean_{name}_sub"] = lambda a, b: (a - b) & mask
+    g[f"lean_{name}_mul"] = lambda a, b: (a * b) & mask
+    g[f"lean_{name}_div"] = lambda a, b: lean_int_div(val(a), val(b)) & mask
+    g[f"lean_{name}_mod"] = lambda a, b: lean_int_mod(val(a), val(b)) & mask
+    g[f"lean_{name}_neg"] = lambda a: (-a) & mask
+    g[f"lean_{name}_land"] = lambda a, b: a & b
+    g[f"lean_{name}_lor"] = lambda a, b: a | b
+    g[f"lean_{name}_xor"] = lambda a, b: a ^ b
+    g[f"lean_{name}_shift_left"] = lambda a, b: (a << (val(b) % bits)) & mask
+    g[f"lean_{name}_shift_right"] = lambda a, b: (val(a) >> (val(b) % bits)) & mask
+    g[f"lean_{name}_complement"] = lambda a: a ^ mask
+    g[f"lean_{name}_abs"] = lambda a: abs(val(a)) & mask
+    g[f"lean_{name}_dec_eq"] = lambda a, b: a == b
+    g[f"lean_{name}_dec_lt"] = lambda a, b: val(a) < val(b)
+    g[f"lean_{name}_dec_le"] = lambda a, b: val(a) <= val(b)
+    g[f"lean_{name}_to_float"] = lambda a: float(val(a))
+    g[f"lean_{name}_to_float32"] = lambda a: _f32(float(val(a)))
+    for other, obits in _SWIDTHS.items():
+        if other != name:
+            omask = (1 << obits) - 1
+            g[f"lean_{name}_to_{other}"] = lambda a, omask=omask: val(a) & omask
+    for other, obits in _WIDTHS.items():
+        omask = (1 << obits) - 1
+        g[f"lean_{name}_to_{other}"] = lambda a, omask=omask: val(a) & omask
+
+
+for _n, _b in _SWIDTHS.items():
+    _define_sint(_n, _b)
+
+
+def lean_bool_to_uint64(a):
+    return 1 if a else 0
+
+
+# ---------------------------------------------------------------------------
+# Float and Float32
+
+_F32 = struct.Struct("<f")
+_F64 = struct.Struct("<d")
+_U32 = struct.Struct("<I")
+_U64 = struct.Struct("<Q")
+
+
+def _f32(x):
+    try:
+        return _F32.unpack(_F32.pack(x))[0]
+    except OverflowError:
+        return math.copysign(math.inf, x)
+
+
+def _float_str(a):
+    if math.isnan(a):
+        return b"NaN"
+    if math.isinf(a):
+        return b"inf" if a > 0 else b"-inf"
+    return f"{a:.6f}".encode()
+
+
+def lean_float_to_string(a):
+    return _float_str(a)
+
+
+def lean_float32_to_string(a):
+    return _float_str(a)
+
+
+def _to_uint(a, bits):
+    if math.isnan(a) or a <= 0:
+        return 0
+    m = (1 << bits) - 1
+    if a >= float(1 << bits):
+        return m
+    return int(a)
+
+
+def _to_int(a, bits):
+    if math.isnan(a):
+        return 0
+    lo = -(1 << (bits - 1))
+    hi = (1 << (bits - 1)) - 1
+    if a <= lo:
+        v = lo
+    elif a >= float(hi):
+        v = hi
+    else:
+        v = int(a)
+    return v & ((1 << bits) - 1)
+
+
+def _div(a, b):
+    try:
+        return a / b
+    except ZeroDivisionError:
+        if math.isnan(a) or a == 0:
+            return math.nan
+        return math.copysign(math.inf, a) * math.copysign(1.0, b)
+
+
+def _libm(f):
+    def g(*args):
+        try:
+            return f(*args)
+        except ValueError:
+            return math.nan
+        except OverflowError:
+            return math.inf
+
+    return g
+
+
+def _libm32(f):
+    def g(*args):
+        return _f32(f(*args))
+
+    return g
+
+
+def _define_float(p, rnd):
+    g = globals()
+    g[f"lean_{p}_add"] = lambda a, b: rnd(a + b)
+    g[f"lean_{p}_sub"] = lambda a, b: rnd(a - b)
+    g[f"lean_{p}_mul"] = lambda a, b: rnd(a * b)
+    g[f"lean_{p}_div"] = lambda a, b: rnd(_div(a, b))
+    g[f"lean_{p}_negate"] = lambda a: -a
+    g[f"lean_{p}_beq"] = lambda a, b: a == b
+    g[f"lean_{p}_decLt"] = lambda a, b: a < b
+    g[f"lean_{p}_decLe"] = lambda a, b: a <= b
+    g[f"lean_{p}_isnan"] = math.isnan
+    g[f"lean_{p}_isfinite"] = lambda a: math.isfinite(a)
+    g[f"lean_{p}_isinf"] = lambda a: math.isinf(a)
+    g[f"lean_{p}_of_nat"] = lambda a: rnd(_nat_to_float(a))
+    g[f"lean_{p}_of_int"] = lambda a: rnd(_int_to_float(a))
+    for name, bits in (("uint8", 8), ("uint16", 16), ("uint32", 32), ("uint64", 64), ("usize", 64)):
+        g[f"lean_{p}_to_{name}"] = lambda a, bits=bits: _to_uint(a, bits)
+    for name, bits in (("int8", 8), ("int16", 16), ("int32", 32), ("int64", 64), ("isize", 64)):
+        g[f"lean_{p}_to_{name}"] = lambda a, bits=bits: _to_int(a, bits)
+    g[f"lean_{p}_scaleb"] = lambda a, b: rnd(_scaleb(a, b))
+    g[f"lean_{p}_frexp"] = lambda a: Ctor(0, [rnd(_frexp(a)[0]), _frexp(a)[1]])
+
+
+def _nat_to_float(a):
+    try:
+        return float(a)
+    except OverflowError:
+        return math.inf
+
+
+def _int_to_float(a):
+    try:
+        return float(a)
+    except OverflowError:
+        return math.copysign(math.inf, a)
+
+
+def _scaleb(a, b):
+    try:
+        return math.ldexp(a, b)
+    except OverflowError:
+        return math.copysign(math.inf, a)
+
+
+def _frexp(a):
+    if not math.isfinite(a):
+        return (a, 0)
+    return math.frexp(a)
+
+
+_define_float("float", lambda x: x)
+_define_float("float32", _f32)
+
+
+def lean_float_of_bits(u):
+    return _F64.unpack(_U64.pack(u))[0]
+
+
+def lean_float_to_bits(a):
+    return _U64.unpack(_F64.pack(a))[0]
+
+
+def lean_float32_of_bits(u):
+    return _F32.unpack(_U32.pack(u))[0]
+
+
+def lean_float32_to_bits(a):
+    return _U32.unpack(_F32.pack(a))[0]
+
+
+def lean_float_to_float32(a):
+    return _f32(a)
+
+
+def lean_float32_to_float(a):
+    return a
+
+
+def lean_float_of_scientific(m, sign, e):
+    try:
+        if sign:
+            return float(m) / (10**e) if e < 400 else _float_div_big(m, e)
+        return float(m * 10**e)
+    except OverflowError:
+        return math.inf
+
+
+def _float_div_big(m, e):
+    from fractions import Fraction
+
+    return float(Fraction(m, 10**e))
+
+
+for _name, _f in (
+    ("sin", math.sin),
+    ("cos", math.cos),
+    ("tan", math.tan),
+    ("asin", math.asin),
+    ("acos", math.acos),
+    ("atan", math.atan),
+    ("atan2", math.atan2),
+    ("sinh", math.sinh),
+    ("cosh", math.cosh),
+    ("tanh", math.tanh),
+    ("asinh", math.asinh),
+    ("acosh", math.acosh),
+    ("atanh", math.atanh),
+    ("exp", math.exp),
+    ("exp2", lambda x: 2.0**x),
+    ("log", math.log),
+    ("log2", math.log2),
+    ("log10", math.log10),
+    ("pow", math.pow),
+    ("sqrt", math.sqrt),
+    ("cbrt", math.cbrt),
+    ("ceil", lambda x: float(math.ceil(x)) if math.isfinite(x) else x),
+    ("floor", lambda x: float(math.floor(x)) if math.isfinite(x) else x),
+    ("round", lambda x: float(math.floor(abs(x) + 0.5)) * math.copysign(1.0, x) if math.isfinite(x) else x),
+    ("fabs", math.fabs),
+    ("fmod", math.fmod),
+    ("fma", math.fma),
+):
+    globals()[_name] = _libm(_f)
+    globals()[_name + "f"] = _libm32(_libm(_f))
+
+# ---------------------------------------------------------------------------
+# Strings (UTF-8 bytes)
+
+
+def _s(b):
+    return b.decode("utf-8", "surrogatepass")
+
+
+def _is_first(c):
+    return (c & 0x80) == 0 or (c & 0xE0) == 0xC0 or (c & 0xF0) == 0xE0 or (c & 0xF8) == 0xF0
+
+
+def _char_size(c):
+    if c & 0x80 == 0:
+        return 1
+    if (c & 0xE0) == 0xC0:
+        return 2
+    if (c & 0xF0) == 0xE0:
+        return 3
+    if (c & 0xF8) == 0xF0:
+        return 4
+    return 1
+
+
+def _get_core(s, i):
+    size = len(s)
+    c = s[i]
+    if c & 0x80 == 0:
+        return c
+    if (c & 0xE0) == 0xC0 and i + 1 < size:
+        r = ((c & 0x1F) << 6) | (s[i + 1] & 0x3F)
+        if r >= 0x80:
+            return r
+    if (c & 0xF0) == 0xE0 and i + 2 < size:
+        r = ((c & 0x0F) << 12) | ((s[i + 1] & 0x3F) << 6) | (s[i + 2] & 0x3F)
+        if r >= 0x800 and not (0xD800 <= r <= 0xDFFF):
+            return r
+    if (c & 0xF8) == 0xF0 and i + 3 < size:
+        r = ((c & 0x07) << 18) | ((s[i + 1] & 0x3F) << 12) | ((s[i + 2] & 0x3F) << 6) | (s[i + 3] & 0x3F)
+        if 0x10000 <= r <= 0x10FFFF:
+            return r
+    return None
+
+
+def _enc(c):
+    return chr(c).encode("utf-8", "surrogatepass")
+
+
+_DEFAULT_CHAR = 65
+
+
+def lean_mk_string(s):
+    return s
+
+
+def lean_string_mk(cs):
+    return "".join(chr(c) for c in _list_to_py(cs)).encode("utf-8", "surrogatepass")
+
+
+def lean_string_data(s):
+    return _py_to_list([ord(c) for c in _s(s)])
+
+
+def lean_string_length(s):
+    if s.isascii():
+        return len(s)
+    return len(_s(s))
+
+
+def lean_string_utf8_byte_size(s):
+    return len(s)
+
+
+def lean_string_push(s, c):
+    return s + _enc(c)
+
+
+def lean_string_append(a, b):
+    return a + b
+
+
+def lean_string_utf8_get(s, i):
+    if i >= len(s):
+        return _DEFAULT_CHAR
+    r = _get_core(s, i)
+    return _DEFAULT_CHAR if r is None else r
+
+
+def lean_string_utf8_get_fast(s, i):
+    c = s[i]
+    if c & 0x80 == 0:
+        return c
+    r = _get_core(s, i)
+    return _DEFAULT_CHAR if r is None else r
+
+
+def lean_string_utf8_get_opt(s, i):
+    if i >= len(s):
+        return 0
+    r = _get_core(s, i)
+    return 0 if r is None else Ctor(1, [r])
+
+
+def lean_string_utf8_get_bang(s, i):
+    if i >= len(s):
+        _panic("PANIC at String.get! Init.Data.String.Basic:0:0: index out of bounds")
+        return _DEFAULT_CHAR
+    r = _get_core(s, i)
+    return _DEFAULT_CHAR if r is None else r
+
+
+def lean_string_utf8_next(s, i):
+    if i >= len(s):
+        return i + 1
+    return i + _char_size(s[i])
+
+
+def lean_string_utf8_next_fast(s, i):
+    return i + _char_size(s[i])
+
+
+def lean_string_utf8_prev(s, i):
+    if i == 0:
+        return 0
+    if i > len(s):
+        return i - 1
+    i -= 1
+    while not _is_first(s[i]):
+        i -= 1
+    return i
+
+
+def lean_string_utf8_at_end(s, i):
+    return i >= len(s)
+
+
+def lean_string_is_valid_pos(s, i):
+    if i > len(s):
+        return False
+    if i == len(s):
+        return True
+    return _is_first(s[i])
+
+
+def lean_string_utf8_extract(s, b, e):
+    sz = len(s)
+    if b >= e or b >= sz:
+        return b""
+    if not _is_first(s[b]):
+        return b""
+    e = min(e, sz)
+    if e < sz and not _is_first(s[e]):
+        e = sz
+    return s[b:e]
+
+
+def lean_string_utf8_extract_fast(s, b, e):
+    return s[b:e]
+
+
+def lean_string_utf8_set(s, i, c):
+    sz = len(s)
+    if i >= sz:
+        return s
+    old = s[i]
+    if not _is_first(old):
+        return s
+    n = min(_char_size(old), sz - i)
+    return s[:i] + _enc(c) + s[i + n :]
+
+
+def lean_string_get_byte_fast(s, i):
+    return s[i]
+
+
+def lean_string_dec_eq(a, b):
+    return a == b
+
+
+def lean_string_dec_lt(a, b):
+    return a < b
+
+
+def lean_string_lt(a, b):
+    return a < b
+
+
+def lean_string_memcmp(s1, s2, lstart, rstart, length):
+    return s1[lstart : lstart + length] == s2[rstart : rstart + length]
+
+
+def lean_string_of_usize(n):
+    return str(n).encode()
+
+
+def lean_string_to_utf8(s):
+    return LByteArray(bytearray(s))
+
+
+def lean_string_from_utf8_unchecked(a):
+    return bytes(a.data)
+
+
+def lean_string_validate_utf8(a):
+    try:
+        bytes(a.data).decode("utf-8")
+        return True
+    except UnicodeDecodeError:
+        return False
+
+
+_M64 = (1 << 64) - 1
+
+
+def _murmur64a(data, seed):
+    m = 0xC6A4A7935BD1E995
+    r = 47
+    n = len(data)
+    h = (seed ^ (n * m)) & _M64
+    nblocks = n // 8
+    for i in range(nblocks):
+        k = int.from_bytes(data[8 * i : 8 * i + 8], "little")
+        k = (k * m) & _M64
+        k ^= k >> r
+        k = (k * m) & _M64
+        h ^= k
+        h = (h * m) & _M64
+    tail = data[8 * nblocks :]
+    if tail:
+        for i in range(len(tail) - 1, -1, -1):
+            h ^= tail[i] << (8 * i)
+        h = (h * m) & _M64
+    h ^= h >> r
+    h = (h * m) & _M64
+    h ^= h >> r
+    return h
+
+
+def lean_string_hash(s):
+    return _murmur64a(s, 11)
+
+
+def lean_uint64_mix_hash(a, b):
+    m = 0xC6A4A7935BD1E995
+    r = 47
+    b = (b * m) & _M64
+    b ^= b >> r
+    b = (b * m) & _M64
+    a ^= b
+    a = (a * m) & _M64
+    return a
+
+
+# ---------------------------------------------------------------------------
+# Arrays
+
+
+def _array_exclusive(a):
+    if a.rc == 1:
+        return a
+    data = a.data
+    for x in data:
+        lean_inc(x)
+    lean_dec(a)
+    return LArray(list(data))
+
+
+def lean_array_mk(xs):
+    items = _list_to_py(xs)
+    for x in items:
+        lean_inc(x)
+    lean_dec(xs)
+    return LArray(items)
+
+
+def lean_array_to_list(a):
+    for x in a.data:
+        lean_inc(x)
+    return _py_to_list(a.data)
+
+
+def lean_mk_empty_array_with_capacity(cap):
+    return LArray([])
+
+
+def lean_mk_array(n, v):
+    if n == 0:
+        lean_dec(v)
+        return LArray([])
+    lean_inc_n(v, n - 1)
+    return LArray([v] * n)
+
+
+def lean_array_get_size(a):
+    return len(a.data)
+
+
+def lean_array_size(a):
+    return len(a.data)
+
+
+def lean_array_fget(a, i):
+    x = a.data[i]
+    lean_inc(x)
+    return x
+
+
+def lean_array_fget_borrowed(a, i):
+    return a.data[i]
+
+
+def lean_array_uget(a, i):
+    x = a.data[i]
+    lean_inc(x)
+    return x
+
+
+def lean_array_uget_borrowed(a, i):
+    return a.data[i]
+
+
+def lean_array_get(default, a, i):
+    if i < len(a.data):
+        lean_dec(default)
+        x = a.data[i]
+        lean_inc(x)
+        return x
+    _panic_oob()
+    return default
+
+
+def lean_array_get_borrowed(default, a, i):
+    if i < len(a.data):
+        return a.data[i]
+    _panic_oob()
+    return default
+
+
+def _panic_oob():
+    _eprint("Error: index out of bounds")
+
+
+def lean_array_push(a, v):
+    a = _array_exclusive(a)
+    a.data.append(v)
+    return a
+
+
+def lean_array_fset(a, i, v):
+    a = _array_exclusive(a)
+    old = a.data[i]
+    a.data[i] = v
+    lean_dec(old)
+    return a
+
+
+def lean_array_uset(a, i, v):
+    return lean_array_fset(a, i, v)
+
+
+def lean_array_set(a, i, v):
+    if i >= len(a.data):
+        lean_dec(v)
+        _panic_oob()
+        return a
+    return lean_array_fset(a, i, v)
+
+
+def lean_array_fswap(a, i, j):
+    a = _array_exclusive(a)
+    d = a.data
+    d[i], d[j] = d[j], d[i]
+    return a
+
+
+def lean_array_swap(a, i, j):
+    n = len(a.data)
+    if i >= n or j >= n:
+        return a
+    return lean_array_fswap(a, i, j)
+
+
+def lean_array_pop(a):
+    a = _array_exclusive(a)
+    if a.data:
+        lean_dec(a.data.pop())
+    return a
+
+
+def lean_array_uswap(a, i, j):
+    return lean_array_fswap(a, i, j)
+
+
+def lean_array_propagate_mark(a):
+    return a
+
+
+def lean_copy_array(a):
+    for x in a.data:
+        lean_inc(x)
+    return LArray(list(a.data))
+
+
+def lean_array_extract(a, start, stop):
+    d = a.data
+    stop = min(stop, len(d))
+    if start >= stop:
+        return LArray([])
+    items = d[start:stop]
+    for x in items:
+        lean_inc(x)
+    return LArray(items)
+
+
+# ---------------------------------------------------------------------------
+# ByteArray and FloatArray
+
+
+def _sarray_exclusive(a, cls):
+    if a.rc == 1:
+        return a
+    lean_dec(a)
+    return cls(a.data.copy())
+
+
+def lean_byte_array_mk(xs):
+    return LByteArray(bytearray(xs.data))
+
+
+def lean_byte_array_data(a):
+    return LArray(list(a.data))
+
+
+def lean_mk_empty_byte_array(cap):
+    return LByteArray(bytearray())
+
+
+def lean_byte_array_size(a):
+    return len(a.data)
+
+
+def lean_sarray_size(a):
+    return len(a.data)
+
+
+def lean_byte_array_get(a, i):
+    return a.data[i] if i < len(a.data) else 0
+
+
+def lean_byte_array_fget(a, i):
+    return a.data[i]
+
+
+def lean_byte_array_uget(a, i):
+    return a.data[i]
+
+
+def lean_byte_array_push(a, v):
+    a = _sarray_exclusive(a, LByteArray)
+    a.data.append(v)
+    return a
+
+
+def lean_byte_array_set(a, i, v):
+    if i >= len(a.data):
+        return a
+    a = _sarray_exclusive(a, LByteArray)
+    a.data[i] = v
+    return a
+
+
+def lean_byte_array_fset(a, i, v):
+    a = _sarray_exclusive(a, LByteArray)
+    a.data[i] = v
+    return a
+
+
+def lean_byte_array_uset(a, i, v):
+    return lean_byte_array_fset(a, i, v)
+
+
+def lean_byte_array_copy_slice(src, src_off, dest, dest_off, length, exact):
+    ssz = len(src.data)
+    dsz = len(dest.data)
+    src_off = min(src_off, ssz)
+    length = min(length, ssz - src_off)
+    dest_off = min(dest_off, dsz)
+    chunk = src.data[src_off : src_off + length]
+    r = _sarray_exclusive(dest, LByteArray)
+    if dest_off + length > dsz:
+        r.data.extend(bytes(dest_off + length - dsz))
+    r.data[dest_off : dest_off + length] = chunk
+    return r
+
+
+def lean_byte_array_hash(a):
+    return _murmur64a(bytes(a.data), 11)
+
+
+def lean_float_array_mk(xs):
+    return LFloatArray(list(xs.data))
+
+
+def lean_float_array_data(a):
+    return LArray(list(a.data))
+
+
+def lean_mk_empty_float_array(cap):
+    return LFloatArray([])
+
+
+def lean_float_array_size(a):
+    return len(a.data)
+
+
+def lean_float_array_get(a, i):
+    return a.data[i] if i < len(a.data) else 0.0
+
+
+def lean_float_array_fget(a, i):
+    return a.data[i]
+
+
+def lean_float_array_uget(a, i):
+    return a.data[i]
+
+
+def lean_float_array_push(a, v):
+    a = _sarray_exclusive(a, LFloatArray)
+    a.data.append(v)
+    return a
+
+
+def lean_float_array_set(a, i, v):
+    if i >= len(a.data):
+        return a
+    a = _sarray_exclusive(a, LFloatArray)
+    a.data[i] = v
+    return a
+
+
+def lean_float_array_fset(a, i, v):
+    a = _sarray_exclusive(a, LFloatArray)
+    a.data[i] = v
+    return a
+
+
+def lean_float_array_uset(a, i, v):
+    return lean_float_array_fset(a, i, v)
+
+
+# ---------------------------------------------------------------------------
+# Thunks and tasks (run synchronously)
+
+
+def lean_mk_thunk(c):
+    return Thunk(c)
+
+
+def lean_thunk_pure(v):
+    return Thunk(None, v, True)
+
+
+def _thunk_force(t):
+    if not t.done:
+        t.value = lean_mark_persistent(lean_apply(t.fn, [0]))
+        t.done = True
+        t.fn = None
+    return t.value
+
+
+def lean_thunk_get_own(t):
+    v = _thunk_force(t)
+    lean_inc(v)
+    return v
+
+
+def lean_thunk_get(t):
+    return _thunk_force(t)
+
+
+def lean_task_pure(v):
+    return Task(lean_mark_persistent(v))
+
+
+def lean_task_spawn(c, prio=0):
+    return Task(lean_mark_persistent(lean_apply(c, [0])))
+
+
+def lean_task_get_own(t):
+    v = t.value
+    lean_inc(v)
+    return v
+
+
+def lean_task_get(t):
+    return t.value
+
+
+def lean_task_map(f, t, prio=0, sync=0):
+    return Task(lean_mark_persistent(lean_apply(f, [t.value])))
+
+
+def lean_task_bind(t, f, prio=0, sync=0):
+    return lean_apply(f, [t.value])
+
+
+def lean_io_wait(t, _w=0):
+    return t.value
+
+
+from lean_python.io_externs import *