jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/irbuild-i64.test

@@ -1,2144 +0,0 @@
-[case testI64Basics]
-from mypy_extensions import i64
-
-def f() -> i64:
-    x: i64 = 5
-    y = x
-    return y
-[out]
-def f():
-    x, y :: i64
-L0:
-    x = 5
-    y = x
-    return y
-
-[case testI64Compare]
-from mypy_extensions import i64
-
-def min(x: i64, y: i64) -> i64:
-    if x < y:
-        return x
-    else:
-        return y
-
-def all_comparisons(x: i64) -> int:
-    if x == 2:
-        y = 10
-    elif 3 != x:
-        y = 11
-    elif x > 4:
-        y = 12
-    elif 6 >= x:
-        y = 13
-    elif x < 5:
-        y = 14
-    elif 6 <= x:
-        y = 15
-    else:
-        y = 16
-    return y
-[out]
-def min(x, y):
-    x, y :: i64
-    r0 :: bit
-L0:
-    r0 = x < y :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return x
-L2:
-    return y
-L3:
-    unreachable
-def all_comparisons(x):
-    x :: i64
-    r0 :: bit
-    y :: int
-    r1, r2, r3, r4, r5 :: bit
-L0:
-    r0 = x == 2
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    y = 20
-    goto L18
-L2:
-    r1 = 3 != x
-    if r1 goto L3 else goto L4 :: bool
-L3:
-    y = 22
-    goto L17
-L4:
-    r2 = x > 4 :: signed
-    if r2 goto L5 else goto L6 :: bool
-L5:
-    y = 24
-    goto L16
-L6:
-    r3 = 6 >= x :: signed
-    if r3 goto L7 else goto L8 :: bool
-L7:
-    y = 26
-    goto L15
-L8:
-    r4 = x < 5 :: signed
-    if r4 goto L9 else goto L10 :: bool
-L9:
-    y = 28
-    goto L14
-L10:
-    r5 = 6 <= x :: signed
-    if r5 goto L11 else goto L12 :: bool
-L11:
-    y = 30
-    goto L13
-L12:
-    y = 32
-L13:
-L14:
-L15:
-L16:
-L17:
-L18:
-    return y
-
-[case testI64Arithmetic]
-from mypy_extensions import i64
-
-def f(x: i64, y: i64) -> i64:
-    z = x + y
-    return y - z
-[out]
-def f(x, y):
-    x, y, r0, z, r1 :: i64
-L0:
-    r0 = x + y
-    z = r0
-    r1 = y - z
-    return r1
-
-[case testI64Negation]
-from mypy_extensions import i64
-
-def f() -> i64:
-    i: i64 = -3
-    return -i
-[out]
-def f():
-    i, r0 :: i64
-L0:
-    i = -3
-    r0 = 0 - i
-    return r0
-
-[case testI64MoreUnaryOps]
-from mypy_extensions import i64
-
-def unary(x: i64) -> i64:
-    y = ~x
-    x = +y
-    return x
-[out]
-def unary(x):
-    x, r0, y :: i64
-L0:
-    r0 = x ^ -1
-    y = r0
-    x = y
-    return x
-
-[case testI64BoxingAndUnboxing]
-from typing import Any
-from mypy_extensions import i64
-
-def f(a: Any) -> None:
-    b: i64 = a
-    a = b
-[out]
-def f(a):
-    a :: object
-    r0, b :: i64
-    r1 :: object
-L0:
-    r0 = unbox(i64, a)
-    b = r0
-    r1 = box(i64, b)
-    a = r1
-    return 1
-
-[case testI64ListGetSetItem]
-from typing import List
-from mypy_extensions import i64
-
-def get(a: List[i64], i: i64) -> i64:
-    return a[i]
-def set(a: List[i64], i: i64, x: i64) -> None:
-    a[i] = x
-[out]
-def get(a, i):
-    a :: list
-    i :: i64
-    r0 :: object
-    r1 :: i64
-L0:
-    r0 = CPyList_GetItemInt64(a, i)
-    r1 = unbox(i64, r0)
-    return r1
-def set(a, i, x):
-    a :: list
-    i, x :: i64
-    r0 :: object
-    r1 :: bit
-L0:
-    r0 = box(i64, x)
-    r1 = CPyList_SetItemInt64(a, i, r0)
-    return 1
-
-[case testI64MixedArithmetic]
-from mypy_extensions import i64
-
-def f() -> i64:
-    a: i64 = 1
-    b = a + 2
-    return 3 - b
-[out]
-def f():
-    a, r0, b, r1 :: i64
-L0:
-    a = 1
-    r0 = a + 2
-    b = r0
-    r1 = 3 - b
-    return r1
-
-[case testI64MixedComparison]
-from mypy_extensions import i64
-
-def f(a: i64) -> i64:
-    if a < 3:
-        return 1
-    elif 3 < a:
-        return 2
-    return 3
-[out]
-def f(a):
-    a :: i64
-    r0, r1 :: bit
-L0:
-    r0 = a < 3 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    r1 = 3 < a :: signed
-    if r1 goto L3 else goto L4 :: bool
-L3:
-    return 2
-L4:
-L5:
-    return 3
-
-[case testI64InplaceOperations]
-from mypy_extensions import i64
-
-def add(a: i64) -> i64:
-    b = a
-    b += 1
-    a += b
-    return a
-def others(a: i64, b: i64) -> i64:
-    a -= b
-    a *= b
-    a &= b
-    a |= b
-    a ^= b
-    a <<= b
-    a >>= b
-    return a
-[out]
-def add(a):
-    a, b, r0, r1 :: i64
-L0:
-    b = a
-    r0 = b + 1
-    b = r0
-    r1 = a + b
-    a = r1
-    return a
-def others(a, b):
-    a, b, r0, r1, r2, r3, r4, r5, r6 :: i64
-L0:
-    r0 = a - b
-    a = r0
-    r1 = a * b
-    a = r1
-    r2 = a & b
-    a = r2
-    r3 = a | b
-    a = r3
-    r4 = a ^ b
-    a = r4
-    r5 = a << b
-    a = r5
-    r6 = a >> b
-    a = r6
-    return a
-
-[case testI64BitwiseOps]
-from mypy_extensions import i64
-
-def forward(a: i64, b: i64) -> i64:
-    b = a & 1
-    a = b | 2
-    b = a ^ 3
-    a = b << 4
-    b = a >> 5
-    return b
-
-def reverse(a: i64, b: i64) -> i64:
-    b = 1 & a
-    a = 2 | b
-    b = 3 ^ a
-    a = 4 << b
-    b = 5 >> a
-    return b
-
-def unary(a: i64) -> i64:
-    return ~a
-[out]
-def forward(a, b):
-    a, b, r0, r1, r2, r3, r4 :: i64
-L0:
-    r0 = a & 1
-    b = r0
-    r1 = b | 2
-    a = r1
-    r2 = a ^ 3
-    b = r2
-    r3 = b << 4
-    a = r3
-    r4 = a >> 5
-    b = r4
-    return b
-def reverse(a, b):
-    a, b, r0, r1, r2, r3, r4 :: i64
-L0:
-    r0 = 1 & a
-    b = r0
-    r1 = 2 | b
-    a = r1
-    r2 = 3 ^ a
-    b = r2
-    r3 = 4 << b
-    a = r3
-    r4 = 5 >> a
-    b = r4
-    return b
-def unary(a):
-    a, r0 :: i64
-L0:
-    r0 = a ^ -1
-    return r0
-
-[case testI64Division]
-from mypy_extensions import i64
-
-def constant_divisor(x: i64) -> i64:
-    return x // 7
-def variable_divisor(x: i64, y: i64) -> i64:
-    return x // y
-def constant_lhs(x: i64) -> i64:
-    return 27 // x
-def divide_by_neg_one(x: i64) -> i64:
-    return x // -1
-def divide_by_zero(x: i64) -> i64:
-    return x // 0
-[out]
-def constant_divisor(x):
-    x, r0, r1 :: i64
-    r2, r3, r4 :: bit
-    r5 :: i64
-    r6 :: bit
-    r7 :: i64
-L0:
-    r0 = x / 7
-    r1 = r0
-    r2 = x < 0 :: signed
-    r3 = 7 < 0 :: signed
-    r4 = r2 == r3
-    if r4 goto L3 else goto L1 :: bool
-L1:
-    r5 = r1 * 7
-    r6 = r5 == x
-    if r6 goto L3 else goto L2 :: bool
-L2:
-    r7 = r1 - 1
-    r1 = r7
-L3:
-    return r1
-def variable_divisor(x, y):
-    x, y, r0 :: i64
-L0:
-    r0 = CPyInt64_Divide(x, y)
-    return r0
-def constant_lhs(x):
-    x, r0 :: i64
-L0:
-    r0 = CPyInt64_Divide(27, x)
-    return r0
-def divide_by_neg_one(x):
-    x, r0 :: i64
-L0:
-    r0 = CPyInt64_Divide(x, -1)
-    return r0
-def divide_by_zero(x):
-    x, r0 :: i64
-L0:
-    r0 = CPyInt64_Divide(x, 0)
-    return r0
-
-[case testI64Mod]
-from mypy_extensions import i64
-
-def constant_divisor(x: i64) -> i64:
-    return x % 7
-def variable_divisor(x: i64, y: i64) -> i64:
-    return x % y
-def constant_lhs(x: i64) -> i64:
-    return 27 % x
-def mod_by_zero(x: i64) -> i64:
-    return x % 0
-[out]
-def constant_divisor(x):
-    x, r0, r1 :: i64
-    r2, r3, r4, r5 :: bit
-    r6 :: i64
-L0:
-    r0 = x % 7
-    r1 = r0
-    r2 = x < 0 :: signed
-    r3 = 7 < 0 :: signed
-    r4 = r2 == r3
-    if r4 goto L3 else goto L1 :: bool
-L1:
-    r5 = r1 == 0
-    if r5 goto L3 else goto L2 :: bool
-L2:
-    r6 = r1 + 7
-    r1 = r6
-L3:
-    return r1
-def variable_divisor(x, y):
-    x, y, r0 :: i64
-L0:
-    r0 = CPyInt64_Remainder(x, y)
-    return r0
-def constant_lhs(x):
-    x, r0 :: i64
-L0:
-    r0 = CPyInt64_Remainder(27, x)
-    return r0
-def mod_by_zero(x):
-    x, r0 :: i64
-L0:
-    r0 = CPyInt64_Remainder(x, 0)
-    return r0
-
-[case testI64InPlaceDiv]
-from mypy_extensions import i64
-
-def by_constant(x: i64) -> i64:
-    x //= 7
-    return x
-def by_variable(x: i64, y: i64) -> i64:
-    x //= y
-    return x
-[out]
-def by_constant(x):
-    x, r0, r1 :: i64
-    r2, r3, r4 :: bit
-    r5 :: i64
-    r6 :: bit
-    r7 :: i64
-L0:
-    r0 = x / 7
-    r1 = r0
-    r2 = x < 0 :: signed
-    r3 = 7 < 0 :: signed
-    r4 = r2 == r3
-    if r4 goto L3 else goto L1 :: bool
-L1:
-    r5 = r1 * 7
-    r6 = r5 == x
-    if r6 goto L3 else goto L2 :: bool
-L2:
-    r7 = r1 - 1
-    r1 = r7
-L3:
-    x = r1
-    return x
-def by_variable(x, y):
-    x, y, r0 :: i64
-L0:
-    r0 = CPyInt64_Divide(x, y)
-    x = r0
-    return x
-
-[case testI64InPlaceMod]
-from mypy_extensions import i64
-
-def by_constant(x: i64) -> i64:
-    x %= 7
-    return x
-def by_variable(x: i64, y: i64) -> i64:
-    x %= y
-    return x
-[out]
-def by_constant(x):
-    x, r0, r1 :: i64
-    r2, r3, r4, r5 :: bit
-    r6 :: i64
-L0:
-    r0 = x % 7
-    r1 = r0
-    r2 = x < 0 :: signed
-    r3 = 7 < 0 :: signed
-    r4 = r2 == r3
-    if r4 goto L3 else goto L1 :: bool
-L1:
-    r5 = r1 == 0
-    if r5 goto L3 else goto L2 :: bool
-L2:
-    r6 = r1 + 7
-    r1 = r6
-L3:
-    x = r1
-    return x
-def by_variable(x, y):
-    x, y, r0 :: i64
-L0:
-    r0 = CPyInt64_Remainder(x, y)
-    x = r0
-    return x
-
-[case testI64ForRange]
-from mypy_extensions import i64
-
-def g(a: i64) -> None: pass
-
-def f(x: i64) -> None:
-    n: i64  # TODO: Infer the type
-    for n in range(x):
-        g(n)
-[out]
-def g(a):
-    a :: i64
-L0:
-    return 1
-def f(x):
-    x, r0, n :: i64
-    r1 :: bit
-    r2 :: None
-    r3 :: i64
-L0:
-    r0 = 0
-    n = r0
-L1:
-    r1 = r0 < x :: signed
-    if r1 goto L2 else goto L4 :: bool
-L2:
-    r2 = g(n)
-L3:
-    r3 = r0 + 1
-    r0 = r3
-    n = r3
-    goto L1
-L4:
-    return 1
-
-[case testI64ConvertFromInt_64bit]
-from mypy_extensions import i64
-
-def int_to_i64(a: int) -> i64:
-    return a
-[out]
-def int_to_i64(a):
-    a :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-L0:
-    r0 = a & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = a >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = a ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive a
-L3:
-    return r3
-
-[case testI64ConvertToInt_64bit]
-from mypy_extensions import i64
-
-def i64_to_int(a: i64) -> int:
-    return a
-[out]
-def i64_to_int(a):
-    a :: i64
-    r0, r1 :: bit
-    r2, r3, r4 :: int
-L0:
-    r0 = a <= 4611686018427387903 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = a >= -4611686018427387904 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(a)
-    r3 = r2
-    goto L4
-L3:
-    r4 = a << 1
-    r3 = r4
-L4:
-    return r3
-
-[case testI64ConvertToInt_32bit]
-from mypy_extensions import i64
-
-def i64_to_int(a: i64) -> int:
-    return a
-[out]
-def i64_to_int(a):
-    a :: i64
-    r0, r1 :: bit
-    r2, r3 :: int
-    r4 :: native_int
-    r5 :: int
-L0:
-    r0 = a <= 1073741823 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = a >= -1073741824 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(a)
-    r3 = r2
-    goto L4
-L3:
-    r4 = truncate a: i64 to native_int
-    r5 = r4 << 1
-    r3 = r5
-L4:
-    return r3
-
-[case testI64Tuple]
-from typing import Tuple
-from mypy_extensions import i64
-
-def f(x: i64, y: i64) -> Tuple[i64, i64]:
-    return x, y
-
-def g() -> Tuple[i64, i64]:
-    return 1, 2
-
-def h() -> i64:
-    x, y = g()
-    t = g()
-    return x + y + t[0]
-[out]
-def f(x, y):
-    x, y :: i64
-    r0 :: tuple[i64, i64]
-L0:
-    r0 = (x, y)
-    return r0
-def g():
-    r0 :: tuple[int, int]
-    r1 :: tuple[i64, i64]
-L0:
-    r0 = (2, 4)
-    r1 = (1, 2)
-    return r1
-def h():
-    r0 :: tuple[i64, i64]
-    r1, x, r2, y :: i64
-    r3, t :: tuple[i64, i64]
-    r4, r5, r6 :: i64
-L0:
-    r0 = g()
-    r1 = r0[0]
-    x = r1
-    r2 = r0[1]
-    y = r2
-    r3 = g()
-    t = r3
-    r4 = x + y
-    r5 = t[0]
-    r6 = r4 + r5
-    return r6
-
-[case testI64MixWithTagged1_64bit]
-from mypy_extensions import i64
-def f(x: i64, y: int) -> i64:
-    return x + y
-[out]
-def f(x, y):
-    x :: i64
-    y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6, r7 :: i64
-L0:
-    r0 = y & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = y >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = y ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive y
-L3:
-    r7 = x + r3
-    return r7
-
-[case testI64MixWithTagged2_64bit]
-from mypy_extensions import i64
-def f(x: int, y: i64) -> i64:
-    return x + y
-[out]
-def f(x, y):
-    x :: int
-    y :: i64
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6, r7 :: i64
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = x ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive x
-L3:
-    r7 = r3 + y
-    return r7
-
-[case testI64MixWithTaggedInPlace1_64bit]
-from mypy_extensions import i64
-def f(y: i64) -> int:
-    x = 0
-    x += y
-    return x
-[out]
-def f(y):
-    y :: i64
-    x :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6, r7 :: i64
-    r8, r9 :: bit
-    r10, r11, r12 :: int
-L0:
-    x = 0
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = x ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive x
-L3:
-    r7 = r3 + y
-    r8 = r7 <= 4611686018427387903 :: signed
-    if r8 goto L4 else goto L5 :: bool
-L4:
-    r9 = r7 >= -4611686018427387904 :: signed
-    if r9 goto L6 else goto L5 :: bool
-L5:
-    r10 = CPyTagged_FromInt64(r7)
-    r11 = r10
-    goto L7
-L6:
-    r12 = r7 << 1
-    r11 = r12
-L7:
-    x = r11
-    return x
-
-[case testI64MixWithTaggedInPlace2_64bit]
-from mypy_extensions import i64
-def f(y: int) -> i64:
-    x: i64 = 0
-    x += y
-    return x
-[out]
-def f(y):
-    y :: int
-    x :: i64
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6, r7 :: i64
-L0:
-    x = 0
-    r0 = y & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = y >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = y ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive y
-L3:
-    r7 = x + r3
-    x = r7
-    return x
-
-[case testI64MixedCompare1_64bit]
-from mypy_extensions import i64
-def f(x: int, y: i64) -> bool:
-    return x == y
-[out]
-def f(x, y):
-    x :: int
-    y :: i64
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-    r7 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = x ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive x
-L3:
-    r7 = r3 == y
-    return r7
-
-[case testI64MixedCompare2_64bit]
-from mypy_extensions import i64
-def f(x: i64, y: int) -> bool:
-    return x == y
-[out]
-def f(x, y):
-    x :: i64
-    y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-    r7 :: bit
-L0:
-    r0 = y & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = y >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = y ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive y
-L3:
-    r7 = x == r3
-    return r7
-
-[case testI64MixedCompare_32bit]
-from mypy_extensions import i64
-def f(x: int, y: i64) -> bool:
-    return x == y
-[out]
-def f(x, y):
-    x :: int
-    y :: i64
-    r0 :: native_int
-    r1 :: bit
-    r2, r3, r4 :: i64
-    r5 :: ptr
-    r6 :: c_ptr
-    r7 :: i64
-    r8 :: bit
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = extend signed x: builtins.int to i64
-    r3 = r2 >> 1
-    r4 = r3
-    goto L3
-L2:
-    r5 = x ^ 1
-    r6 = r5
-    r7 = CPyLong_AsInt64(r6)
-    r4 = r7
-    keep_alive x
-L3:
-    r8 = r4 == y
-    return r8
-
-[case testI64AsBool]
-from mypy_extensions import i64
-def f(x: i64) -> i64:
-    if x:
-        return 5
-    elif not x:
-        return 6
-    return 3
-[out]
-def f(x):
-    x :: i64
-    r0, r1 :: bit
-L0:
-    r0 = x != 0
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return 5
-L2:
-    r1 = x != 0
-    if r1 goto L4 else goto L3 :: bool
-L3:
-    return 6
-L4:
-L5:
-    return 3
-
-[case testI64AssignMixed_64bit]
-from mypy_extensions import i64
-def f(x: i64, y: int) -> i64:
-    x = y
-    return x
-def g(x: i64, y: int) -> int:
-    y = x
-    return y
-[out]
-def f(x, y):
-    x :: i64
-    y :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-L0:
-    r0 = y & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = y >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = y ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive y
-L3:
-    x = r3
-    return x
-def g(x, y):
-    x :: i64
-    y :: int
-    r0, r1 :: bit
-    r2, r3, r4 :: int
-L0:
-    r0 = x <= 4611686018427387903 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = x >= -4611686018427387904 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(x)
-    r3 = r2
-    goto L4
-L3:
-    r4 = x << 1
-    r3 = r4
-L4:
-    y = r3
-    return y
-
-[case testBorrowOverI64Arithmetic]
-from mypy_extensions import i64
-
-def add_simple(c: C) -> i64:
-    return c.x + c.y
-
-def inplace_add_simple(c: C) -> None:
-    c.x += c.y
-
-def add_borrow(d: D) -> i64:
-    return d.c.x + d.c.y
-
-class D:
-    c: C
-
-class C:
-    x: i64
-    y: i64
-[out]
-def add_simple(c):
-    c :: __main__.C
-    r0, r1, r2 :: i64
-L0:
-    r0 = c.x
-    r1 = c.y
-    r2 = r0 + r1
-    return r2
-def inplace_add_simple(c):
-    c :: __main__.C
-    r0, r1, r2 :: i64
-    r3 :: bool
-L0:
-    r0 = c.x
-    r1 = c.y
-    r2 = r0 + r1
-    c.x = r2; r3 = is_error
-    return 1
-def add_borrow(d):
-    d :: __main__.D
-    r0 :: __main__.C
-    r1 :: i64
-    r2 :: __main__.C
-    r3, r4 :: i64
-L0:
-    r0 = borrow d.c
-    r1 = r0.x
-    r2 = borrow d.c
-    r3 = r2.y
-    r4 = r1 + r3
-    keep_alive d, d
-    return r4
-
-[case testBorrowOverI64Bitwise]
-from mypy_extensions import i64
-
-def bitwise_simple(c: C) -> i64:
-    return c.x | c.y
-
-def inplace_bitwide_simple(c: C) -> None:
-    c.x &= c.y
-
-def bitwise_borrow(d: D) -> i64:
-    return d.c.x ^ d.c.y
-
-class D:
-    c: C
-
-class C:
-    x: i64
-    y: i64
-[out]
-def bitwise_simple(c):
-    c :: __main__.C
-    r0, r1, r2 :: i64
-L0:
-    r0 = c.x
-    r1 = c.y
-    r2 = r0 | r1
-    return r2
-def inplace_bitwide_simple(c):
-    c :: __main__.C
-    r0, r1, r2 :: i64
-    r3 :: bool
-L0:
-    r0 = c.x
-    r1 = c.y
-    r2 = r0 & r1
-    c.x = r2; r3 = is_error
-    return 1
-def bitwise_borrow(d):
-    d :: __main__.D
-    r0 :: __main__.C
-    r1 :: i64
-    r2 :: __main__.C
-    r3, r4 :: i64
-L0:
-    r0 = borrow d.c
-    r1 = r0.x
-    r2 = borrow d.c
-    r3 = r2.y
-    r4 = r1 ^ r3
-    keep_alive d, d
-    return r4
-
-[case testBorrowOverI64ListGetItem1]
-from mypy_extensions import i64
-
-def f(n: i64) -> str:
-    a = [C()]
-    return a[n].s
-
-class C:
-    s: str
-[out]
-def f(n):
-    n :: i64
-    r0 :: __main__.C
-    r1 :: list
-    r2 :: ptr
-    a :: list
-    r3 :: object
-    r4 :: __main__.C
-    r5 :: str
-L0:
-    r0 = C()
-    r1 = PyList_New(1)
-    r2 = list_items r1
-    buf_init_item r2, 0, r0
-    keep_alive r1
-    a = r1
-    r3 = CPyList_GetItemInt64Borrow(a, n)
-    r4 = borrow cast(__main__.C, r3)
-    r5 = r4.s
-    keep_alive a, n, r3
-    return r5
-
-[case testBorrowOverI64ListGetItem2]
-from typing import List
-from mypy_extensions import i64
-
-def f(a: List[i64], n: i64) -> bool:
-    if a[n] == 0:
-        return True
-    return False
-[out]
-def f(a, n):
-    a :: list
-    n :: i64
-    r0 :: object
-    r1 :: i64
-    r2 :: bit
-L0:
-    r0 = CPyList_GetItemInt64Borrow(a, n)
-    r1 = unbox(i64, r0)
-    r2 = r1 == 0
-    keep_alive a, n
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-
-[case testCoerceShortIntToI64]
-from mypy_extensions import i64
-from typing import List
-
-def f(a: List[i64], y: i64) -> bool:
-    if len(a) < y:
-        return True
-    return False
-
-def g(a: List[i64], y: i64) -> bool:
-    if y < len(a):
-        return True
-    return False
-[out]
-def f(a, y):
-    a :: list
-    y :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2 :: i64
-    r3 :: bit
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = r2 < y :: signed
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-def g(a, y):
-    a :: list
-    y :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2 :: i64
-    r3 :: bit
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = y < r2 :: signed
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-
-[case testMultiplyListByI64_64bit]
-from mypy_extensions import i64
-from typing import List
-
-def f(n: i64) -> List[i64]:
-    return [n] * n
-[out]
-def f(n):
-    n :: i64
-    r0 :: list
-    r1 :: object
-    r2 :: ptr
-    r3, r4 :: bit
-    r5, r6, r7 :: int
-    r8 :: list
-L0:
-    r0 = PyList_New(1)
-    r1 = box(i64, n)
-    r2 = list_items r0
-    buf_init_item r2, 0, r1
-    keep_alive r0
-    r3 = n <= 4611686018427387903 :: signed
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = n >= -4611686018427387904 :: signed
-    if r4 goto L3 else goto L2 :: bool
-L2:
-    r5 = CPyTagged_FromInt64(n)
-    r6 = r5
-    goto L4
-L3:
-    r7 = n << 1
-    r6 = r7
-L4:
-    r8 = CPySequence_Multiply(r0, r6)
-    return r8
-
-[case testShortIntAndI64Op]
-from mypy_extensions import i64
-from typing import List
-
-def add_i64(a: List[i64], n: i64) -> i64:
-    return len(a) + n
-def add_i64_2(a: List[i64], n: i64) -> i64:
-    return n + len(a)
-def eq_i64(a: List[i64], n: i64) -> bool:
-    if len(a) == n:
-        return True
-    return False
-def lt_i64(a: List[i64], n: i64) -> bool:
-    if n < len(a):
-        return True
-    return False
-[out]
-def add_i64(a, n):
-    a :: list
-    n :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2, r3 :: i64
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = r2 + n
-    return r3
-def add_i64_2(a, n):
-    a :: list
-    n :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2, r3 :: i64
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = n + r2
-    return r3
-def eq_i64(a, n):
-    a :: list
-    n :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2 :: i64
-    r3 :: bit
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = r2 == n
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-def lt_i64(a, n):
-    a :: list
-    n :: i64
-    r0 :: native_int
-    r1 :: short_int
-    r2 :: i64
-    r3 :: bit
-L0:
-    r0 = var_object_size a
-    r1 = r0 << 1
-    r2 = r1 >> 1
-    r3 = n < r2 :: signed
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-
-[case testOptionalI64_64bit]
-from typing import Optional
-from mypy_extensions import i64
-
-def f(x: Optional[i64]) -> i64:
-    if x is None:
-        return 1
-    return x
-[out]
-def f(x):
-    x :: union[i64, None]
-    r0 :: object
-    r1 :: bit
-    r2 :: i64
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = x == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    r2 = unbox(i64, x)
-    return r2
-
-[case testI64DefaultValueSingle]
-from mypy_extensions import i64
-
-def f(x: i64, y: i64 = 0) -> i64:
-    return x + y
-
-def g() -> i64:
-    return f(7) + f(8, 9)
-[out]
-def f(x, y, __bitmap):
-    x, y :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-    r2 :: i64
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    y = 0
-L2:
-    r2 = x + y
-    return r2
-def g():
-    r0, r1, r2 :: i64
-L0:
-    r0 = f(7, 0, 0)
-    r1 = f(8, 9, 1)
-    r2 = r0 + r1
-    return r2
-
-[case testI64DefaultValueWithMultipleArgs]
-from mypy_extensions import i64
-
-def f(a: i64, b: i64 = 1, c: int = 2, d: i64 = 3) -> i64:
-    return 0
-
-def g() -> i64:
-    return f(7) + f(8, 9) + f(1, 2, 3) + f(4, 5, 6, 7)
-[out]
-def f(a, b, c, d, __bitmap):
-    a, b :: i64
-    c :: int
-    d :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-    r2 :: u32
-    r3 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    b = 1
-L2:
-    if is_error(c) goto L3 else goto L4
-L3:
-    c = 4
-L4:
-    r2 = __bitmap & 2
-    r3 = r2 == 0
-    if r3 goto L5 else goto L6 :: bool
-L5:
-    d = 3
-L6:
-    return 0
-def g():
-    r0 :: int
-    r1 :: i64
-    r2 :: int
-    r3, r4, r5, r6, r7, r8 :: i64
-L0:
-    r0 = <error> :: int
-    r1 = f(7, 0, r0, 0, 0)
-    r2 = <error> :: int
-    r3 = f(8, 9, r2, 0, 1)
-    r4 = r1 + r3
-    r5 = f(1, 2, 6, 0, 1)
-    r6 = r4 + r5
-    r7 = f(4, 5, 12, 7, 3)
-    r8 = r6 + r7
-    return r8
-
-[case testI64MethodDefaultValue]
-from mypy_extensions import i64
-
-class C:
-    def m(self, x: i64 = 5) -> None:
-        pass
-
-def f(c: C) -> None:
-    c.m()
-    c.m(6)
-[out]
-def C.m(self, x, __bitmap):
-    self :: __main__.C
-    x :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 5
-L2:
-    return 1
-def f(c):
-    c :: __main__.C
-    r0, r1 :: None
-L0:
-    r0 = c.m(0, 0)
-    r1 = c.m(6, 1)
-    return 1
-
-[case testI64ExplicitConversionFromNativeInt]
-from mypy_extensions import i64, i32, i16
-
-def from_i16(x: i16) -> i64:
-    return i64(x)
-
-def from_i32(x: i32) -> i64:
-    return i64(x)
-
-def from_i64(x: i64) -> i64:
-    return i64(x)
-[out]
-def from_i16(x):
-    x :: i16
-    r0 :: i64
-L0:
-    r0 = extend signed x: i16 to i64
-    return r0
-def from_i32(x):
-    x :: i32
-    r0 :: i64
-L0:
-    r0 = extend signed x: i32 to i64
-    return r0
-def from_i64(x):
-    x :: i64
-L0:
-    return x
-
-[case testI64ExplicitConversionFromInt_64bit]
-from mypy_extensions import i64
-
-def f(x: int) -> i64:
-    return i64(x)
-[out]
-def f(x):
-    x :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = x ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive x
-L3:
-    return r3
-
-[case testI64ExplicitConversionToInt_64bit]
-from mypy_extensions import i64
-
-def f(x: i64) -> int:
-    return int(x)
-[out]
-def f(x):
-    x :: i64
-    r0, r1 :: bit
-    r2, r3, r4 :: int
-L0:
-    r0 = x <= 4611686018427387903 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = x >= -4611686018427387904 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(x)
-    r3 = r2
-    goto L4
-L3:
-    r4 = x << 1
-    r3 = r4
-L4:
-    return r3
-
-[case testI64ExplicitConversionFromLiteral]
-from mypy_extensions import i64
-
-def f() -> None:
-    x = i64(0)
-    y = i64(11)
-    z = i64(-3)
-[out]
-def f():
-    x, y, z :: i64
-L0:
-    x = 0
-    y = 11
-    z = -3
-    return 1
-
-[case testI64ForLoopOverRange]
-from mypy_extensions import i64
-
-def f() -> None:
-    for x in range(i64(4)):
-        y = x
-[out]
-def f():
-    r0, x :: i64
-    r1 :: bit
-    y, r2 :: i64
-L0:
-    r0 = 0
-    x = r0
-L1:
-    r1 = r0 < 4 :: signed
-    if r1 goto L2 else goto L4 :: bool
-L2:
-    y = x
-L3:
-    r2 = r0 + 1
-    r0 = r2
-    x = r2
-    goto L1
-L4:
-    return 1
-
-[case testI64ForLoopOverRange2]
-from mypy_extensions import i64
-
-def f() -> None:
-    for x in range(0, i64(4)):
-        y = x
-[out]
-def f():
-    r0, x :: i64
-    r1 :: bit
-    y, r2 :: i64
-L0:
-    r0 = 0
-    x = r0
-L1:
-    r1 = r0 < 4 :: signed
-    if r1 goto L2 else goto L4 :: bool
-L2:
-    y = x
-L3:
-    r2 = r0 + 1
-    r0 = r2
-    x = r2
-    goto L1
-L4:
-    return 1
-
-[case testI64MethodDefaultValueOverride]
-from mypy_extensions import i64
-
-class C:
-    def f(self, x: i64 = 11) -> None: pass
-class D(C):
-    def f(self, x: i64 = 12) -> None: pass
-[out]
-def C.f(self, x, __bitmap):
-    self :: __main__.C
-    x :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 11
-L2:
-    return 1
-def D.f(self, x, __bitmap):
-    self :: __main__.D
-    x :: i64
-    __bitmap, r0 :: u32
-    r1 :: bit
-L0:
-    r0 = __bitmap & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    x = 12
-L2:
-    return 1
-
-[case testI64FinalConstants]
-from typing_extensions import Final
-from mypy_extensions import i64
-
-A: Final = -1
-B: Final = -(1 + 3*2)
-C: Final = 0
-D: Final = A - B
-E: Final[i64] = 1 + 3
-
-def f1() -> i64:
-    return A
-
-def f2() -> i64:
-    return A + B
-
-def f3() -> i64:
-    return C
-
-def f4() -> i64:
-    return D
-
-def f5() -> i64:
-    return E
-[out]
-def f1():
-L0:
-    return -1
-def f2():
-L0:
-    return -8
-def f3():
-L0:
-    return 0
-def f4():
-L0:
-    return 6
-def f5():
-L0:
-    return 4
-
-[case testI64OperationsWithBools]
-from mypy_extensions import i64
-
-# TODO: Other mixed operations
-
-def add_bool_to_int(n: i64, b: bool) -> i64:
-    return n + b
-
-def compare_bool_to_i64(n: i64, b: bool) -> bool:
-    if n == b:
-        return b != n
-    return True
-[out]
-def add_bool_to_int(n, b):
-    n :: i64
-    b :: bool
-    r0, r1 :: i64
-L0:
-    r0 = extend b: builtins.bool to i64
-    r1 = n + r0
-    return r1
-def compare_bool_to_i64(n, b):
-    n :: i64
-    b :: bool
-    r0 :: i64
-    r1 :: bit
-    r2 :: i64
-    r3 :: bit
-L0:
-    r0 = extend b: builtins.bool to i64
-    r1 = n == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = extend b: builtins.bool to i64
-    r3 = r2 != n
-    return r3
-L2:
-    return 1
-
-[case testI64Cast_64bit]
-from typing import cast
-from mypy_extensions import i64
-
-def cast_object(o: object) -> i64:
-    return cast(i64, o)
-
-def cast_int(x: int) -> i64:
-    return cast(i64, x)
-[out]
-def cast_object(o):
-    o :: object
-    r0 :: i64
-L0:
-    r0 = unbox(i64, o)
-    return r0
-def cast_int(x):
-    x :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3 :: i64
-    r4 :: ptr
-    r5 :: c_ptr
-    r6 :: i64
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = x >> 1
-    r3 = r2
-    goto L3
-L2:
-    r4 = x ^ 1
-    r5 = r4
-    r6 = CPyLong_AsInt64(r5)
-    r3 = r6
-    keep_alive x
-L3:
-    return r3
-
-[case testI64Cast_32bit]
-from typing import cast
-from mypy_extensions import i64
-
-def cast_int(x: int) -> i64:
-    return cast(i64, x)
-[out]
-def cast_int(x):
-    x :: int
-    r0 :: native_int
-    r1 :: bit
-    r2, r3, r4 :: i64
-    r5 :: ptr
-    r6 :: c_ptr
-    r7 :: i64
-L0:
-    r0 = x & 1
-    r1 = r0 == 0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = extend signed x: builtins.int to i64
-    r3 = r2 >> 1
-    r4 = r3
-    goto L3
-L2:
-    r5 = x ^ 1
-    r6 = r5
-    r7 = CPyLong_AsInt64(r6)
-    r4 = r7
-    keep_alive x
-L3:
-    return r4
-
-[case testI64ExplicitConversionFromVariousTypes_64bit]
-from mypy_extensions import i64
-
-def bool_to_i64(b: bool) -> i64:
-    return i64(b)
-
-def str_to_i64(s: str) -> i64:
-    return i64(s)
-
-def str_to_i64_with_base(s: str) -> i64:
-    return i64(s, 2)
-
-class C:
-    def __int__(self) -> i64:
-        return 5
-
-def instance_to_i64(c: C) -> i64:
-    return i64(c)
-
-def float_to_i64(x: float) -> i64:
-    return i64(x)
-[out]
-def bool_to_i64(b):
-    b :: bool
-    r0 :: i64
-L0:
-    r0 = extend b: builtins.bool to i64
-    return r0
-def str_to_i64(s):
-    s :: str
-    r0 :: object
-    r1 :: i64
-L0:
-    r0 = CPyLong_FromStr(s)
-    r1 = unbox(i64, r0)
-    return r1
-def str_to_i64_with_base(s):
-    s :: str
-    r0 :: object
-    r1 :: i64
-L0:
-    r0 = CPyLong_FromStrWithBase(s, 4)
-    r1 = unbox(i64, r0)
-    return r1
-def C.__int__(self):
-    self :: __main__.C
-L0:
-    return 5
-def instance_to_i64(c):
-    c :: __main__.C
-    r0 :: i64
-L0:
-    r0 = c.__int__()
-    return r0
-def float_to_i64(x):
-    x :: float
-    r0 :: int
-    r1 :: native_int
-    r2 :: bit
-    r3, r4 :: i64
-    r5 :: ptr
-    r6 :: c_ptr
-    r7 :: i64
-L0:
-    r0 = CPyTagged_FromFloat(x)
-    r1 = r0 & 1
-    r2 = r1 == 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = r0 >> 1
-    r4 = r3
-    goto L3
-L2:
-    r5 = r0 ^ 1
-    r6 = r5
-    r7 = CPyLong_AsInt64(r6)
-    r4 = r7
-    keep_alive r0
-L3:
-    return r4
-
-[case testI64ExplicitConversionFromFloat_32bit]
-from mypy_extensions import i64
-
-def float_to_i64(x: float) -> i64:
-    return i64(x)
-[out]
-def float_to_i64(x):
-    x :: float
-    r0 :: int
-    r1 :: native_int
-    r2 :: bit
-    r3, r4, r5 :: i64
-    r6 :: ptr
-    r7 :: c_ptr
-    r8 :: i64
-L0:
-    r0 = CPyTagged_FromFloat(x)
-    r1 = r0 & 1
-    r2 = r1 == 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = extend signed r0: builtins.int to i64
-    r4 = r3 >> 1
-    r5 = r4
-    goto L3
-L2:
-    r6 = r0 ^ 1
-    r7 = r6
-    r8 = CPyLong_AsInt64(r7)
-    r5 = r8
-    keep_alive r0
-L3:
-    return r5
-
-[case testI64ConvertToFloat_64bit]
-from mypy_extensions import i64
-
-def i64_to_float(x: i64) -> float:
-    return float(x)
-[out]
-def i64_to_float(x):
-    x :: i64
-    r0, r1 :: bit
-    r2, r3, r4 :: int
-    r5 :: float
-L0:
-    r0 = x <= 4611686018427387903 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = x >= -4611686018427387904 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(x)
-    r3 = r2
-    goto L4
-L3:
-    r4 = x << 1
-    r3 = r4
-L4:
-    r5 = CPyFloat_FromTagged(r3)
-    return r5
-
-[case testI64ConvertToFloat_32bit]
-from mypy_extensions import i64
-
-def i64_to_float(x: i64) -> float:
-    return float(x)
-[out]
-def i64_to_float(x):
-    x :: i64
-    r0, r1 :: bit
-    r2, r3 :: int
-    r4 :: native_int
-    r5 :: int
-    r6 :: float
-L0:
-    r0 = x <= 1073741823 :: signed
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = x >= -1073741824 :: signed
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    r2 = CPyTagged_FromInt64(x)
-    r3 = r2
-    goto L4
-L3:
-    r4 = truncate x: i64 to native_int
-    r5 = r4 << 1
-    r3 = r5
-L4:
-    r6 = CPyFloat_FromTagged(r3)
-    return r6
-
-[case testI64IsinstanceNarrowing]
-from typing import Union
-from mypy_extensions import i64
-
-class C:
-    a: i64
-
-def narrow1(x: Union[C, i64]) -> i64:
-    if isinstance(x, i64):
-        return x
-    return x.a
-
-def narrow2(x: Union[C, i64]) -> i64:
-    if isinstance(x, int):
-        return x
-    return x.a
-[out]
-def narrow1(x):
-    x :: union[__main__.C, i64]
-    r0 :: object
-    r1 :: i32
-    r2 :: bit
-    r3 :: bool
-    r4 :: i64
-    r5 :: __main__.C
-    r6 :: i64
-L0:
-    r0 = load_address PyLong_Type
-    r1 = PyObject_IsInstance(x, r0)
-    r2 = r1 >= 0 :: signed
-    r3 = truncate r1: i32 to builtins.bool
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = unbox(i64, x)
-    return r4
-L2:
-    r5 = borrow cast(__main__.C, x)
-    r6 = r5.a
-    keep_alive x
-    return r6
-def narrow2(x):
-    x :: union[__main__.C, i64]
-    r0 :: object
-    r1 :: i32
-    r2 :: bit
-    r3 :: bool
-    r4 :: i64
-    r5 :: __main__.C
-    r6 :: i64
-L0:
-    r0 = load_address PyLong_Type
-    r1 = PyObject_IsInstance(x, r0)
-    r2 = r1 >= 0 :: signed
-    r3 = truncate r1: i32 to builtins.bool
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = unbox(i64, x)
-    return r4
-L2:
-    r5 = borrow cast(__main__.C, x)
-    r6 = r5.a
-    keep_alive x
-    return r6
-
-[case testI64ConvertBetweenTuples_64bit]
-from __future__ import annotations
-from mypy_extensions import i64
-
-def f(t: tuple[int, i64, int]) -> None:
-    tt: tuple[int, i64, i64] = t
-
-def g(n: int) -> None:
-    t: tuple[i64, i64] = (1, n)
-[out]
-def f(t):
-    t :: tuple[int, i64, int]
-    r0 :: int
-    r1 :: i64
-    r2 :: int
-    r3 :: native_int
-    r4 :: bit
-    r5, r6 :: i64
-    r7 :: ptr
-    r8 :: c_ptr
-    r9 :: i64
-    r10, tt :: tuple[int, i64, i64]
-L0:
-    r0 = t[0]
-    r1 = t[1]
-    r2 = t[2]
-    r3 = r2 & 1
-    r4 = r3 == 0
-    if r4 goto L1 else goto L2 :: bool
-L1:
-    r5 = r2 >> 1
-    r6 = r5
-    goto L3
-L2:
-    r7 = r2 ^ 1
-    r8 = r7
-    r9 = CPyLong_AsInt64(r8)
-    r6 = r9
-    keep_alive r2
-L3:
-    r10 = (r0, r1, r6)
-    tt = r10
-    return 1
-def g(n):
-    n :: int
-    r0 :: tuple[int, int]
-    r1 :: int
-    r2 :: native_int
-    r3 :: bit
-    r4, r5 :: i64
-    r6 :: ptr
-    r7 :: c_ptr
-    r8 :: i64
-    r9, t :: tuple[i64, i64]
-L0:
-    r0 = (2, n)
-    r1 = r0[1]
-    r2 = r1 & 1
-    r3 = r2 == 0
-    if r3 goto L1 else goto L2 :: bool
-L1:
-    r4 = r1 >> 1
-    r5 = r4
-    goto L3
-L2:
-    r6 = r1 ^ 1
-    r7 = r6
-    r8 = CPyLong_AsInt64(r7)
-    r5 = r8
-    keep_alive r1
-L3:
-    r9 = (1, r5)
-    t = r9
-    return 1