jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

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

@@ -0,0 +1,2144 @@
+[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