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

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

@@ -1,3399 +0,0 @@
-[case testTrivialFunction]
-def f() -> int:
-    return 1
-[out]
-def f():
-L0:
-    return 2
-[case testFunctionArgument]
-def f(x: int) -> int:
-    return x
-[out]
-def f(x):
-    x :: int
-L0:
-    return x
-
-
-[case testExplicitNoneReturn]
-def f() -> None:
-    return
-[out]
-def f():
-L0:
-    return 1
-
-[case testExplicitNoneReturn2]
-def f() -> None:
-    return None
-[out]
-def f():
-L0:
-    return 1
-
-[case testAssignment]
-def f() -> int:
-    x = 1
-    y = x
-    return y
-[out]
-def f():
-    x, y :: int
-L0:
-    x = 2
-    y = x
-    return y
-
-[case testAssignmentTwice]
-def f(x: int) -> None:
-    y = 1
-    y = x
-    return
-[out]
-def f(x):
-    x, y :: int
-L0:
-    y = 2
-    y = x
-    return 1
-
-[case testIntArithmetic]
-def f(x: int, y: int) -> int:
-    return x * (y + 1)
-[out]
-def f(x, y):
-    x, y, r0, r1 :: int
-L0:
-    r0 = CPyTagged_Add(y, 2)
-    r1 = CPyTagged_Multiply(x, r0)
-    return r1
-
-[case testIf]
-def f(x: int, y: int) -> int:
-    if x < y:
-        x = 1
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    x = 2
-L2:
-    return x
-
-[case testIfElse]
-def f(x: int, y: int) -> int:
-    if x < y:
-        x = 1
-    else:
-        x = 2
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    x = 2
-    goto L3
-L2:
-    x = 4
-L3:
-    return x
-
-[case testAnd1]
-def f(x: int, y: int) -> int:
-    if x < y and x > y:
-        x = 1
-    else:
-        x = 2
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0, r1 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L1 else goto L3 :: bool
-L1:
-    r1 = int_gt x, y
-    if r1 goto L2 else goto L3 :: bool
-L2:
-    x = 2
-    goto L4
-L3:
-    x = 4
-L4:
-    return x
-
-[case testAnd2]
-def f(x: object, y: object) -> str:
-    return str(x) or str(y)
-[out]
-def f(x, y):
-    x, y :: object
-    r0 :: str
-    r1 :: bit
-    r2, r3 :: str
-L0:
-    r0 = PyObject_Str(x)
-    r1 = CPyStr_IsTrue(r0)
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = r0
-    goto L3
-L2:
-    r3 = PyObject_Str(y)
-    r2 = r3
-L3:
-    return r2
-
-[case testOr]
-def f(x: int, y: int) -> int:
-    if x < y or x > y:
-        x = 1
-    else:
-        x = 2
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0, r1 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L2 else goto L1 :: bool
-L1:
-    r1 = int_gt x, y
-    if r1 goto L2 else goto L3 :: bool
-L2:
-    x = 2
-    goto L4
-L3:
-    x = 4
-L4:
-    return x
-
-[case testOr2]
-def f(x: object, y: object) -> str:
-    return str(x) and str(y)
-[out]
-def f(x, y):
-    x, y :: object
-    r0 :: str
-    r1 :: bit
-    r2, r3 :: str
-L0:
-    r0 = PyObject_Str(x)
-    r1 = CPyStr_IsTrue(r0)
-    if r1 goto L2 else goto L1 :: bool
-L1:
-    r2 = r0
-    goto L3
-L2:
-    r3 = PyObject_Str(y)
-    r2 = r3
-L3:
-    return r2
-
-[case testSimpleNot]
-def f(x: int, y: int) -> int:
-    if not (x < y):
-        x = 1
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L2 else goto L1 :: bool
-L1:
-    x = 2
-L2:
-    return x
-
-[case testNotAnd]
-def f(x: int, y: int) -> int:
-    if not (x < y and x > y):
-        x = 1
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0, r1 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = int_gt x, y
-    if r1 goto L3 else goto L2 :: bool
-L2:
-    x = 2
-L3:
-    return x
-
-[case testWhile]
-def f(x: int, y: int) -> int:
-    while x > y:
-        x = x - y
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-    r1 :: int
-L0:
-L1:
-    r0 = int_gt x, y
-    if r0 goto L2 else goto L3 :: bool
-L2:
-    r1 = CPyTagged_Subtract(x, y)
-    x = r1
-    goto L1
-L3:
-    return x
-
-[case testWhile2]
-def f(x: int, y: int) -> int:
-    x = 1
-    while x > y:
-        x = x - y
-    return x
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-    r1 :: int
-L0:
-    x = 2
-L1:
-    r0 = int_gt x, y
-    if r0 goto L2 else goto L3 :: bool
-L2:
-    r1 = CPyTagged_Subtract(x, y)
-    x = r1
-    goto L1
-L3:
-    return x
-
-[case testImplicitNoneReturn]
-def f() -> None:
-    pass
-[out]
-def f():
-L0:
-    return 1
-
-[case testImplicitNoneReturn2]
-def f() -> None:
-    x = 1
-[out]
-def f():
-    x :: int
-L0:
-    x = 2
-    return 1
-
-[case testImplicitNoneReturnAndIf]
-def f(x: int, y: int) -> None:
-    if x < y:
-        x = 1
-    else:
-        y = 2
-[out]
-def f(x, y):
-    x, y :: int
-    r0 :: bit
-L0:
-    r0 = int_lt x, y
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    x = 2
-    goto L3
-L2:
-    y = 4
-L3:
-    return 1
-
-[case testRecursion]
-def f(n: int) -> int:
-    if n <= 1:
-        return 1
-    else:
-        return f(n - 1) + f(n - 2)
-[out]
-def f(n):
-    n :: int
-    r0 :: bit
-    r1, r2, r3, r4, r5 :: int
-L0:
-    r0 = int_le n, 2
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    r1 = CPyTagged_Subtract(n, 2)
-    r2 = f(r1)
-    r3 = CPyTagged_Subtract(n, 4)
-    r4 = f(r3)
-    r5 = CPyTagged_Add(r2, r4)
-    return r5
-L3:
-    unreachable
-
-[case testReportTypeCheckError]
-def f() -> None:
-    return 1 # E: No return value expected
-
-[case testReportSemanticaAnalysisError1]
-def f(x: List[int]) -> None: pass # E: Name "List" is not defined \
-                                  # N: Did you forget to import it from "typing"? (Suggestion: "from typing import List")
-
-[case testReportSemanticaAnalysisError2]
-def f() -> None:
-    x # E: Name "x" is not defined
-
-[case testElif]
-def f(n: int) -> int:
-    if n < 0:
-        x = 1
-    elif n == 0:
-        x = 1
-    else:
-        x = 2
-    return x
-[out]
-def f(n):
-    n :: int
-    r0 :: bit
-    x :: int
-    r1 :: bit
-L0:
-    r0 = int_lt n, 0
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    x = 2
-    goto L6
-L2:
-    r1 = int_eq n, 0
-    if r1 goto L3 else goto L4 :: bool
-L3:
-    x = 2
-    goto L5
-L4:
-    x = 4
-L5:
-L6:
-    return x
-
-[case testUnaryMinus]
-def f(n: int) -> int:
-    return -n
-[out]
-def f(n):
-    n, r0 :: int
-L0:
-    r0 = CPyTagged_Negate(n)
-    return r0
-
-[case testConditionalExpr]
-def f(n: int) -> int:
-    return 0 if n == 0 else 1
-[out]
-def f(n):
-    n :: int
-    r0 :: bit
-    r1 :: int
-L0:
-    r0 = int_eq n, 0
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = 0
-    goto L3
-L2:
-    r1 = 2
-L3:
-    return r1
-
-[case testOperatorAssignment]
-def f() -> int:
-    x = 0
-    x += 1
-    return x
-[out]
-def f():
-    x, r0 :: int
-L0:
-    x = 0
-    r0 = CPyTagged_Add(x, 2)
-    x = r0
-    return x
-
-[case testTrue]
-def f() -> bool:
-    return True
-[out]
-def f():
-L0:
-    return 1
-
-[case testFalse]
-def f() -> bool:
-    return False
-[out]
-def f():
-L0:
-    return 0
-[case testBoolCond]
-def f(x: bool) -> bool:
-    if x:
-        return False
-    else:
-        return True
-[out]
-def f(x):
-    x :: bool
-L0:
-    if x goto L1 else goto L2 :: bool
-L1:
-    return 0
-L2:
-    return 1
-L3:
-    unreachable
-
-[case testPycall]
-import testmodule
-
-def f(x: int) -> int:
-    return testmodule.factorial(x)
-[file testmodule.py]
-def factorial(x: int) -> int:
-    if x == 0:
-        return 1
-    else:
-        return x * factorial(x-1)
-[out]
-def f(x):
-    x :: int
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
-L0:
-    r0 = testmodule :: module
-    r1 = 'factorial'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
-
-[case testImport_toplevel]
-import sys
-import enum as enum2
-import collections.abc
-import collections.abc as abc2
-_ = "filler"
-import single
-single.hello()
-
-[file single.py]
-def hello() -> None:
-    print("hello, world")
-
-[out]
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4 :: object
-    r5, r6, r7, r8 :: object_ptr
-    r9 :: object_ptr[4]
-    r10 :: c_ptr
-    r11 :: native_int[4]
-    r12 :: c_ptr
-    r13 :: object
-    r14 :: dict
-    r15, r16 :: str
-    r17 :: bit
-    r18 :: str
-    r19 :: dict
-    r20 :: str
-    r21 :: i32
-    r22 :: bit
-    r23 :: object_ptr
-    r24 :: object_ptr[1]
-    r25 :: c_ptr
-    r26 :: native_int[1]
-    r27 :: c_ptr
-    r28 :: object
-    r29 :: dict
-    r30, r31 :: str
-    r32 :: bit
-    r33 :: object
-    r34 :: str
-    r35, r36 :: object
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = load_address sys :: module
-    r6 = load_address enum :: module
-    r7 = load_address collections.abc :: module
-    r8 = load_address collections.abc :: module
-    r9 = [r5, r6, r7, r8]
-    r10 = load_address r9
-    r11 = [1, 2, 3, 4]
-    r12 = load_address r11
-    r13 = (('sys', 'sys', 'sys'), ('enum', 'enum', 'enum2'), ('collections.abc', 'collections', 'collections'), ('collections.abc', 'collections.abc', 'abc2'))
-    r14 = __main__.globals :: static
-    r15 = 'main'
-    r16 = '<module>'
-    r17 = CPyImport_ImportMany(r13, r10, r14, r15, r16, r12)
-    r18 = 'filler'
-    r19 = __main__.globals :: static
-    r20 = '_'
-    r21 = CPyDict_SetItem(r19, r20, r18)
-    r22 = r21 >= 0 :: signed
-    r23 = load_address single :: module
-    r24 = [r23]
-    r25 = load_address r24
-    r26 = [6]
-    r27 = load_address r26
-    r28 = (('single', 'single', 'single'),)
-    r29 = __main__.globals :: static
-    r30 = 'main'
-    r31 = '<module>'
-    r32 = CPyImport_ImportMany(r28, r25, r29, r30, r31, r27)
-    r33 = single :: module
-    r34 = 'hello'
-    r35 = CPyObject_GetAttr(r33, r34)
-    r36 = PyObject_CallFunctionObjArgs(r35, 0)
-    return 1
-
-[case testFromImport_toplevel]
-from testmodule import g, h
-from testmodule import h as two
-
-def f(x: int) -> int:
-    return g(x) + h() + two()
-[file testmodule.py]
-def g(x: int) -> int:
-    return x + 1
-def h() -> int:
-    return 2
-[out]
-def f(x):
-    x :: int
-    r0 :: dict
-    r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
-    r6 :: dict
-    r7 :: str
-    r8, r9 :: object
-    r10, r11 :: int
-    r12 :: dict
-    r13 :: str
-    r14, r15 :: object
-    r16, r17 :: int
-L0:
-    r0 = __main__.globals :: static
-    r1 = 'g'
-    r2 = CPyDict_GetItem(r0, r1)
-    r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    r6 = __main__.globals :: static
-    r7 = 'h'
-    r8 = CPyDict_GetItem(r6, r7)
-    r9 = PyObject_CallFunctionObjArgs(r8, 0)
-    r10 = unbox(int, r9)
-    r11 = CPyTagged_Add(r5, r10)
-    r12 = __main__.globals :: static
-    r13 = 'two'
-    r14 = CPyDict_GetItem(r12, r13)
-    r15 = PyObject_CallFunctionObjArgs(r14, 0)
-    r16 = unbox(int, r15)
-    r17 = CPyTagged_Add(r11, r16)
-    return r17
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4, r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8, r9, r10 :: object
-    r11 :: str
-    r12 :: dict
-    r13 :: object
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = ('g', 'h')
-    r6 = 'testmodule'
-    r7 = __main__.globals :: static
-    r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)
-    testmodule = r8 :: module
-    r9 = ('h',)
-    r10 = ('two',)
-    r11 = 'testmodule'
-    r12 = __main__.globals :: static
-    r13 = CPyImport_ImportFromMany(r11, r9, r10, r12)
-    testmodule = r13 :: module
-    return 1
-
-[case testPrintFullname]
-import builtins
-def f(x: int) -> None:
-    builtins.print(5)
-[out]
-def f(x):
-    x :: int
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'print'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = object 5
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    return 1
-
-[case testPrint]
-import builtins
-def f(x: int) -> None:
-    print(5)
-[out]
-def f(x):
-    x :: int
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'print'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = object 5
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    return 1
-
-[case testUnicodeLiteral]
-def f() -> str:
-    x = "some string"
-    return "some other string"
-[out]
-def f():
-    r0, x, r1 :: str
-L0:
-    r0 = 'some string'
-    x = r0
-    r1 = 'some other string'
-    return r1
-
-[case testBytesLiteral]
-def f() -> bytes:
-    x = b'\xf0'
-    return b'1234'
-[out]
-def f():
-    r0, x, r1 :: bytes
-L0:
-    r0 = b'\xf0'
-    x = r0
-    r1 = b'1234'
-    return r1
-
-[case testPyMethodCall1]
-from typing import Any
-def f(x: Any) -> int:
-    y: int = x.pop()
-    return x.pop()
-[out]
-def f(x):
-    x :: object
-    r0 :: str
-    r1 :: object
-    r2, y :: int
-    r3 :: str
-    r4 :: object
-    r5 :: int
-L0:
-    r0 = 'pop'
-    r1 = CPyObject_CallMethodObjArgs(x, r0, 0)
-    r2 = unbox(int, r1)
-    y = r2
-    r3 = 'pop'
-    r4 = CPyObject_CallMethodObjArgs(x, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
-
-[case testObjectType]
-def g(y: object) -> None:
-    g(y)
-    g([1])
-    g(None)
-[out]
-def g(y):
-    y :: object
-    r0 :: None
-    r1 :: list
-    r2 :: object
-    r3 :: ptr
-    r4 :: None
-    r5 :: object
-    r6 :: None
-L0:
-    r0 = g(y)
-    r1 = PyList_New(1)
-    r2 = object 1
-    r3 = list_items r1
-    buf_init_item r3, 0, r2
-    keep_alive r1
-    r4 = g(r1)
-    r5 = box(None, 1)
-    r6 = g(r5)
-    return 1
-
-[case testCoerceToObject1]
-def g(y: object) -> object:
-    g(1)
-    a = [y]
-    a[0] = (1, 2)
-    y = True
-    return 3
-[out]
-def g(y):
-    y, r0, r1 :: object
-    r2 :: list
-    r3 :: ptr
-    a :: list
-    r4 :: tuple[int, int]
-    r5 :: object
-    r6 :: bit
-    r7, r8 :: object
-L0:
-    r0 = object 1
-    r1 = g(r0)
-    r2 = PyList_New(1)
-    r3 = list_items r2
-    buf_init_item r3, 0, y
-    keep_alive r2
-    a = r2
-    r4 = (2, 4)
-    r5 = box(tuple[int, int], r4)
-    r6 = CPyList_SetItem(a, 0, r5)
-    r7 = box(bool, 1)
-    y = r7
-    r8 = object 3
-    return r8
-
-[case testCoerceToObject2]
-class A:
-    x: object
-    n: int
-def f(a: A, o: object) -> None:
-    a.x = 1
-    o = a.n
-[out]
-def f(a, o):
-    a :: __main__.A
-    o, r0 :: object
-    r1 :: bool
-    r2 :: int
-    r3 :: object
-L0:
-    r0 = object 1
-    a.x = r0; r1 = is_error
-    r2 = a.n
-    r3 = box(int, r2)
-    o = r3
-    return 1
-
-[case testAssertType]
-from typing import assert_type
-def f(x: int) -> None:
-    y = assert_type(x, int)
-[out]
-def f(x):
-    x, y :: int
-L0:
-    y = x
-    return 1
-
-[case testDownCast]
-from typing import cast, List, Tuple
-class A: pass
-def f(x: object) -> None:
-    n = cast(int, x)
-    b = cast(bool, x)
-    a = cast(A, x)
-    l = cast(List[int], x)
-    t = cast(Tuple[int, A], x)
-[out]
-def f(x):
-    x :: object
-    r0, n :: int
-    r1, b :: bool
-    r2, a :: __main__.A
-    r3, l :: list
-    r4, t :: tuple[int, __main__.A]
-L0:
-    r0 = unbox(int, x)
-    n = r0
-    r1 = unbox(bool, x)
-    b = r1
-    r2 = cast(__main__.A, x)
-    a = r2
-    r3 = cast(list, x)
-    l = r3
-    r4 = unbox(tuple[int, __main__.A], x)
-    t = r4
-    return 1
-
-[case testDownCastSpecialCases]
-from typing import cast, Optional, Tuple
-class A: pass
-def f(o: Optional[A], n: int, t: Tuple[int, ...], tt: Tuple[int, int]) -> None:
-    a = cast(A, o)
-    m = cast(bool, n)
-    t = tt
-[out]
-def f(o, n, t, tt):
-    o :: union[__main__.A, None]
-    n :: int
-    t :: tuple
-    tt :: tuple[int, int]
-    r0, a :: __main__.A
-    r1 :: object
-    r2, m :: bool
-    r3 :: object
-L0:
-    r0 = cast(__main__.A, o)
-    a = r0
-    r1 = box(int, n)
-    r2 = unbox(bool, r1)
-    m = r2
-    r3 = box(tuple[int, int], tt)
-    t = r3
-    return 1
-
-[case testSuccessfulCast]
-from typing import cast, Optional, Tuple, List, Dict
-class A: pass
-def f(o: object,
-      p: Optional[A],
-      n: int,
-      b: bool,
-      t: Tuple[int, ...],
-      s: Tuple[int, int],
-      a: A,
-      l: List[A],
-      d: Dict[int, str]) -> None:
-    o = cast(object, o)
-    p = cast(Optional[A], p)
-    n = cast(int, n)
-    b = cast(bool, b)
-    t = cast(Tuple[int, ...], t)
-    s = cast(Tuple[int, int], s)
-    o = cast(object, n)
-    a = cast(A, a)
-    l2 = cast(List[object], l)
-    d2 = cast(Dict[object, str], d)
-[out]
-def f(o, p, n, b, t, s, a, l, d):
-    o :: object
-    p :: union[__main__.A, None]
-    n :: int
-    b :: bool
-    t :: tuple
-    s :: tuple[int, int]
-    a :: __main__.A
-    l :: list
-    d :: dict
-    r0 :: object
-    l2 :: list
-    d2 :: dict
-L0:
-    o = o
-    p = p
-    n = n
-    b = b
-    t = t
-    s = s
-    r0 = box(int, n)
-    o = r0
-    a = a
-    l2 = l
-    d2 = d
-    return 1
-
-[case testGenericSetItem]
-from typing import Any
-def f(x: Any, y: Any, z: Any) -> None:
-    x[y] = z
-[out]
-def f(x, y, z):
-    x, y, z :: object
-    r0 :: i32
-    r1 :: bit
-L0:
-    r0 = PyObject_SetItem(x, y, z)
-    r1 = r0 >= 0 :: signed
-    return 1
-
-[case testLoadFloatSum]
-def assign_and_return_float_sum() -> float:
-    f1 = 1.0
-    f2 = 2.0
-    f3 = 3.0
-    return f1 * f2 + f3
-[out]
-def assign_and_return_float_sum():
-    f1, f2, f3, r0, r1 :: float
-L0:
-    f1 = 1.0
-    f2 = 2.0
-    f3 = 3.0
-    r0 = f1 * f2
-    r1 = r0 + f3
-    return r1
-
-[case testLoadComplex]
-def load() -> complex:
-    real = 1
-    return 5j+real
-[out]
-def load():
-    real :: int
-    r0, r1, r2 :: object
-L0:
-    real = 2
-    r0 = 5j
-    r1 = box(int, real)
-    r2 = PyNumber_Add(r0, r1)
-    return r2
-
-[case testBigIntLiteral_64bit]
-def big_int() -> None:
-    a_62_bit = 4611686018427387902
-    max_62_bit = 4611686018427387903
-    b_63_bit = 4611686018427387904
-    c_63_bit = 9223372036854775806
-    max_63_bit = 9223372036854775807
-    d_64_bit = 9223372036854775808
-    max_32_bit = 2147483647
-    max_31_bit = 1073741823
-[out]
-def big_int():
-    a_62_bit, max_62_bit, r0, b_63_bit, r1, c_63_bit, r2, max_63_bit, r3, d_64_bit, max_32_bit, max_31_bit :: int
-L0:
-    a_62_bit = 9223372036854775804
-    max_62_bit = 9223372036854775806
-    r0 = object 4611686018427387904
-    b_63_bit = r0
-    r1 = object 9223372036854775806
-    c_63_bit = r1
-    r2 = object 9223372036854775807
-    max_63_bit = r2
-    r3 = object 9223372036854775808
-    d_64_bit = r3
-    max_32_bit = 4294967294
-    max_31_bit = 2147483646
-    return 1
-
-[case testBigIntLiteral_32bit]
-def big_int() -> None:
-    a_62_bit = 4611686018427387902
-    max_62_bit = 4611686018427387903
-    b_63_bit = 4611686018427387904
-    c_63_bit = 9223372036854775806
-    max_63_bit = 9223372036854775807
-    d_64_bit = 9223372036854775808
-    max_32_bit = 2147483647
-    max_31_bit = 1073741823
-[out]
-def big_int():
-    r0, a_62_bit, r1, max_62_bit, r2, b_63_bit, r3, c_63_bit, r4, max_63_bit, r5, d_64_bit, r6, max_32_bit, max_31_bit :: int
-L0:
-    r0 = object 4611686018427387902
-    a_62_bit = r0
-    r1 = object 4611686018427387903
-    max_62_bit = r1
-    r2 = object 4611686018427387904
-    b_63_bit = r2
-    r3 = object 9223372036854775806
-    c_63_bit = r3
-    r4 = object 9223372036854775807
-    max_63_bit = r4
-    r5 = object 9223372036854775808
-    d_64_bit = r5
-    r6 = object 2147483647
-    max_32_bit = r6
-    max_31_bit = 2147483646
-    return 1
-
-[case testCallableTypes]
-from typing import Callable, Any
-from m import f
-
-def absolute_value(x: int) -> int:
-    return x if x > 0 else -x
-
-def call_native_function(x: int) -> int:
-    return absolute_value(x)
-
-def call_python_function(x: int) -> int:
-    return f(x)
-
-def return_float() -> float:
-    return 5.0
-
-def return_callable_type() -> Callable[[], float]:
-    return return_float
-
-def call_callable_type() -> float:
-    f = return_callable_type()
-    return f()
-[file m.py]
-def f(x: int) -> int:
-    return x
-[out]
-def absolute_value(x):
-    x :: int
-    r0 :: bit
-    r1, r2 :: int
-L0:
-    r0 = int_gt x, 0
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = x
-    goto L3
-L2:
-    r2 = CPyTagged_Negate(x)
-    r1 = r2
-L3:
-    return r1
-def call_native_function(x):
-    x, r0 :: int
-L0:
-    r0 = absolute_value(x)
-    return r0
-def call_python_function(x):
-    x :: int
-    r0 :: dict
-    r1 :: str
-    r2, r3, r4 :: object
-    r5 :: int
-L0:
-    r0 = __main__.globals :: static
-    r1 = 'f'
-    r2 = CPyDict_GetItem(r0, r1)
-    r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = unbox(int, r4)
-    return r5
-def return_float():
-L0:
-    return 5.0
-def return_callable_type():
-    r0 :: dict
-    r1 :: str
-    r2 :: object
-L0:
-    r0 = __main__.globals :: static
-    r1 = 'return_float'
-    r2 = CPyDict_GetItem(r0, r1)
-    return r2
-def call_callable_type():
-    r0, f, r1 :: object
-    r2 :: float
-L0:
-    r0 = return_callable_type()
-    f = r0
-    r1 = PyObject_CallFunctionObjArgs(f, 0)
-    r2 = unbox(float, r1)
-    return r2
-
-[case testCallableTypesWithKeywordArgs]
-from typing import List
-
-def call_python_function_with_keyword_arg(x: str) -> int:
-    return int(x, base=2)
-
-def call_python_method_with_keyword_args(xs: List[int], first: int, second: int) -> List[int]:
-    xs.insert(0, x=first)
-    xs.insert(x=second, i=1)
-    return xs
-
-[out]
-def call_python_function_with_keyword_arg(x):
-    x :: str
-    r0 :: object
-    r1 :: str
-    r2 :: tuple
-    r3 :: object
-    r4 :: dict
-    r5 :: object
-    r6 :: int
-L0:
-    r0 = load_address PyLong_Type
-    r1 = 'base'
-    r2 = PyTuple_Pack(1, x)
-    r3 = object 2
-    r4 = CPyDict_Build(1, r1, r3)
-    r5 = PyObject_Call(r0, r2, r4)
-    r6 = unbox(int, r5)
-    return r6
-def call_python_method_with_keyword_args(xs, first, second):
-    xs :: list
-    first, second :: int
-    r0 :: str
-    r1 :: object
-    r2 :: str
-    r3 :: object
-    r4 :: tuple
-    r5 :: object
-    r6 :: dict
-    r7 :: object
-    r8 :: str
-    r9 :: object
-    r10, r11 :: str
-    r12 :: tuple
-    r13, r14 :: object
-    r15 :: dict
-    r16 :: object
-L0:
-    r0 = 'insert'
-    r1 = CPyObject_GetAttr(xs, r0)
-    r2 = 'x'
-    r3 = object 0
-    r4 = PyTuple_Pack(1, r3)
-    r5 = box(int, first)
-    r6 = CPyDict_Build(1, r2, r5)
-    r7 = PyObject_Call(r1, r4, r6)
-    r8 = 'insert'
-    r9 = CPyObject_GetAttr(xs, r8)
-    r10 = 'x'
-    r11 = 'i'
-    r12 = PyTuple_Pack(0)
-    r13 = box(int, second)
-    r14 = object 1
-    r15 = CPyDict_Build(2, r10, r13, r11, r14)
-    r16 = PyObject_Call(r9, r12, r15)
-    return xs
-
-[case testObjectAsBoolean]
-from typing import List
-
-def obj(x: object) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-
-def num(x: int) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-
-def lst(x: List[int]) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-[out]
-def obj(x):
-    x :: object
-    r0 :: i32
-    r1 :: bit
-    r2 :: bool
-L0:
-    r0 = PyObject_IsTrue(x)
-    r1 = r0 >= 0 :: signed
-    r2 = truncate r0: i32 to builtins.bool
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 0
-L3:
-    unreachable
-def num(x):
-    x :: int
-    r0 :: bit
-L0:
-    r0 = x != 0
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 0
-L3:
-    unreachable
-def lst(x):
-    x :: list
-    r0 :: native_int
-    r1 :: short_int
-    r2 :: bit
-L0:
-    r0 = var_object_size x
-    r1 = r0 << 1
-    r2 = int_ne r1, 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 0
-L3:
-    unreachable
-
-[case testOptionalAsBoolean]
-from typing import Optional
-
-class A: pass
-
-def opt_int(x: Optional[int]) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-
-def opt_a(x: Optional[A]) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-
-def opt_o(x: Optional[object]) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-[out]
-def opt_int(x):
-    x :: union[int, None]
-    r0 :: object
-    r1 :: bit
-    r2 :: int
-    r3 :: bit
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = x != r0
-    if r1 goto L1 else goto L3 :: bool
-L1:
-    r2 = unbox(int, x)
-    r3 = r2 != 0
-    if r3 goto L2 else goto L3 :: bool
-L2:
-    return 2
-L3:
-    return 0
-L4:
-    unreachable
-def opt_a(x):
-    x :: union[__main__.A, None]
-    r0 :: object
-    r1 :: bit
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = x != r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 0
-L3:
-    unreachable
-def opt_o(x):
-    x :: union[object, None]
-    r0 :: object
-    r1 :: bit
-    r2 :: object
-    r3 :: i32
-    r4 :: bit
-    r5 :: bool
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = x != r0
-    if r1 goto L1 else goto L3 :: bool
-L1:
-    r2 = cast(object, x)
-    r3 = PyObject_IsTrue(r2)
-    r4 = r3 >= 0 :: signed
-    r5 = truncate r3: i32 to builtins.bool
-    if r5 goto L2 else goto L3 :: bool
-L2:
-    return 2
-L3:
-    return 0
-L4:
-    unreachable
-
-[case testRaise]
-def foo() -> None:
-    raise Exception()
-
-def bar() -> None:
-    raise Exception
-[out]
-def foo():
-    r0 :: object
-    r1 :: str
-    r2, r3 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'Exception'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = PyObject_CallFunctionObjArgs(r2, 0)
-    CPy_Raise(r3)
-    unreachable
-def bar():
-    r0 :: object
-    r1 :: str
-    r2 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'Exception'
-    r2 = CPyObject_GetAttr(r0, r1)
-    CPy_Raise(r2)
-    unreachable
-
-[case testModuleTopLevel_toplevel]
-x = 1
-print(x)
-
-def f() -> None:
-    print(x)
-[out]
-def f():
-    r0 :: dict
-    r1 :: str
-    r2 :: object
-    r3 :: int
-    r4 :: object
-    r5 :: str
-    r6, r7, r8 :: object
-L0:
-    r0 = __main__.globals :: static
-    r1 = 'x'
-    r2 = CPyDict_GetItem(r0, r1)
-    r3 = unbox(int, r2)
-    r4 = builtins :: module
-    r5 = 'print'
-    r6 = CPyObject_GetAttr(r4, r5)
-    r7 = box(int, r3)
-    r8 = PyObject_CallFunctionObjArgs(r6, r7, 0)
-    return 1
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4 :: object
-    r5 :: dict
-    r6 :: str
-    r7 :: object
-    r8 :: i32
-    r9 :: bit
-    r10 :: dict
-    r11 :: str
-    r12 :: object
-    r13 :: int
-    r14 :: object
-    r15 :: str
-    r16, r17, r18 :: object
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = __main__.globals :: static
-    r6 = 'x'
-    r7 = object 1
-    r8 = CPyDict_SetItem(r5, r6, r7)
-    r9 = r8 >= 0 :: signed
-    r10 = __main__.globals :: static
-    r11 = 'x'
-    r12 = CPyDict_GetItem(r10, r11)
-    r13 = unbox(int, r12)
-    r14 = builtins :: module
-    r15 = 'print'
-    r16 = CPyObject_GetAttr(r14, r15)
-    r17 = box(int, r13)
-    r18 = PyObject_CallFunctionObjArgs(r16, r17, 0)
-    return 1
-
-[case testCallOverloaded]
-import m
-def f() -> str:
-    return m.f(1)
-[file m.pyi]
-from typing import overload
-@overload
-def f(x: int) -> str: ...
-@overload
-def f(x: str) -> int: ...
-[out]
-def f():
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-    r5 :: str
-L0:
-    r0 = m :: module
-    r1 = 'f'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = object 1
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    r5 = cast(str, r4)
-    return r5
-
-[case testCallOverloadedNative]
-from typing import overload, Union
-
-@overload
-def foo(x: int) -> int: ...
-
-@overload
-def foo(x: str) -> str: ...
-
-def foo(x: Union[int, str]) -> Union[int, str]:
-    return x
-
-def main() -> None:
-    x = foo(0)
-[out]
-def foo(x):
-    x :: union[int, str]
-L0:
-    return x
-def main():
-    r0 :: object
-    r1 :: union[int, str]
-    r2, x :: int
-L0:
-    r0 = object 0
-    r1 = foo(r0)
-    r2 = unbox(int, r1)
-    x = r2
-    return 1
-
-[case testCallOverloadedNativeSubclass]
-from typing import overload, Union
-
-class A:
-    x: int
-class B(A):
-    y: int
-
-@overload
-def foo(x: int) -> B: ...
-
-@overload
-def foo(x: Union[int, str]) -> A: ...
-
-def foo(x: Union[int, str]) -> A:
-    if isinstance(x, int):
-        return B()
-    return A()
-
-def main() -> None:
-    x = foo(0)
-[out]
-def foo(x):
-    x :: union[int, str]
-    r0 :: object
-    r1 :: i32
-    r2 :: bit
-    r3 :: bool
-    r4 :: __main__.B
-    r5 :: __main__.A
-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 = B()
-    return r4
-L2:
-    r5 = A()
-    return r5
-def main():
-    r0 :: object
-    r1 :: __main__.A
-    r2, x :: __main__.B
-L0:
-    r0 = object 0
-    r1 = foo(r0)
-    r2 = cast(__main__.B, r1)
-    x = r2
-    return 1
-
-[case testFunctionCallWithKeywordArgs]
-def f(x: int, y: str) -> None: pass
-
-def g() -> None:
-    f(y='a', x=0)
-    f(1, y='b')
-[out]
-def f(x, y):
-    x :: int
-    y :: str
-L0:
-    return 1
-def g():
-    r0 :: str
-    r1 :: None
-    r2 :: str
-    r3 :: None
-L0:
-    r0 = 'a'
-    r1 = f(0, r0)
-    r2 = 'b'
-    r3 = f(2, r2)
-    return 1
-
-[case testMethodCallWithKeywordArgs]
-class A:
-    def f(self, x: int, y: str) -> None: pass
-
-def g(a: A) -> None:
-    a.f(y='a', x=0)
-    a.f(1, y='b')
-[out]
-def A.f(self, x, y):
-    self :: __main__.A
-    x :: int
-    y :: str
-L0:
-    return 1
-def g(a):
-    a :: __main__.A
-    r0 :: str
-    r1 :: None
-    r2 :: str
-    r3 :: None
-L0:
-    r0 = 'a'
-    r1 = a.f(0, r0)
-    r2 = 'b'
-    r3 = a.f(2, r2)
-    return 1
-
-[case testStarArgs]
-from typing import Tuple
-def f(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-def g() -> Tuple[int, int, int]:
-    return f(*(1, 2, 3))
-def h() -> Tuple[int, int, int]:
-    return f(1, *(2, 3))
-[out]
-def f(a, b, c):
-    a, b, c :: int
-    r0 :: tuple[int, int, int]
-L0:
-    r0 = (a, b, c)
-    return r0
-def g():
-    r0 :: tuple[int, int, int]
-    r1 :: dict
-    r2 :: str
-    r3 :: object
-    r4 :: list
-    r5, r6 :: object
-    r7 :: tuple
-    r8 :: dict
-    r9 :: object
-    r10 :: tuple[int, int, int]
-L0:
-    r0 = (2, 4, 6)
-    r1 = __main__.globals :: static
-    r2 = 'f'
-    r3 = CPyDict_GetItem(r1, r2)
-    r4 = PyList_New(0)
-    r5 = box(tuple[int, int, int], r0)
-    r6 = CPyList_Extend(r4, r5)
-    r7 = PyList_AsTuple(r4)
-    r8 = PyDict_New()
-    r9 = PyObject_Call(r3, r7, r8)
-    r10 = unbox(tuple[int, int, int], r9)
-    return r10
-def h():
-    r0 :: tuple[int, int]
-    r1 :: dict
-    r2 :: str
-    r3 :: object
-    r4 :: list
-    r5 :: object
-    r6 :: ptr
-    r7, r8 :: object
-    r9 :: tuple
-    r10 :: dict
-    r11 :: object
-    r12 :: tuple[int, int, int]
-L0:
-    r0 = (4, 6)
-    r1 = __main__.globals :: static
-    r2 = 'f'
-    r3 = CPyDict_GetItem(r1, r2)
-    r4 = PyList_New(1)
-    r5 = object 1
-    r6 = list_items r4
-    buf_init_item r6, 0, r5
-    keep_alive r4
-    r7 = box(tuple[int, int], r0)
-    r8 = CPyList_Extend(r4, r7)
-    r9 = PyList_AsTuple(r4)
-    r10 = PyDict_New()
-    r11 = PyObject_Call(r3, r9, r10)
-    r12 = unbox(tuple[int, int, int], r11)
-    return r12
-
-[case testStar2Args]
-from typing import Tuple
-def f(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-def g() -> Tuple[int, int, int]:
-    return f(**{'a': 1, 'b': 2, 'c': 3})
-def h() -> Tuple[int, int, int]:
-    return f(1, **{'b': 2, 'c': 3})
-[out]
-def f(a, b, c):
-    a, b, c :: int
-    r0 :: tuple[int, int, int]
-L0:
-    r0 = (a, b, c)
-    return r0
-def g():
-    r0, r1, r2 :: str
-    r3, r4, r5 :: object
-    r6, r7 :: dict
-    r8 :: str
-    r9 :: object
-    r10 :: dict
-    r11 :: i32
-    r12 :: bit
-    r13 :: tuple
-    r14 :: object
-    r15 :: tuple[int, int, int]
-L0:
-    r0 = 'a'
-    r1 = 'b'
-    r2 = 'c'
-    r3 = object 1
-    r4 = object 2
-    r5 = object 3
-    r6 = CPyDict_Build(3, r0, r3, r1, r4, r2, r5)
-    r7 = __main__.globals :: static
-    r8 = 'f'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = PyDict_New()
-    r11 = CPyDict_UpdateInDisplay(r10, r6)
-    r12 = r11 >= 0 :: signed
-    r13 = PyTuple_Pack(0)
-    r14 = PyObject_Call(r9, r13, r10)
-    r15 = unbox(tuple[int, int, int], r14)
-    return r15
-def h():
-    r0, r1 :: str
-    r2, r3 :: object
-    r4, r5 :: dict
-    r6 :: str
-    r7 :: object
-    r8 :: dict
-    r9 :: i32
-    r10 :: bit
-    r11 :: object
-    r12 :: tuple
-    r13 :: object
-    r14 :: tuple[int, int, int]
-L0:
-    r0 = 'b'
-    r1 = 'c'
-    r2 = object 2
-    r3 = object 3
-    r4 = CPyDict_Build(2, r0, r2, r1, r3)
-    r5 = __main__.globals :: static
-    r6 = 'f'
-    r7 = CPyDict_GetItem(r5, r6)
-    r8 = PyDict_New()
-    r9 = CPyDict_UpdateInDisplay(r8, r4)
-    r10 = r9 >= 0 :: signed
-    r11 = object 1
-    r12 = PyTuple_Pack(1, r11)
-    r13 = PyObject_Call(r7, r12, r8)
-    r14 = unbox(tuple[int, int, int], r13)
-    return r14
-
-[case testFunctionCallWithDefaultArgs]
-def f(x: int, y: int = 3, z: str = "test") -> None:
-    return None
-
-def g() -> None:
-    f(2)
-    f(y = 3, x = 6)
-[out]
-def f(x, y, z):
-    x, y :: int
-    z, r0 :: str
-L0:
-    if is_error(y) goto L1 else goto L2
-L1:
-    y = 6
-L2:
-    if is_error(z) goto L3 else goto L4
-L3:
-    r0 = 'test'
-    z = r0
-L4:
-    return 1
-def g():
-    r0 :: int
-    r1 :: str
-    r2 :: None
-    r3 :: str
-    r4 :: None
-L0:
-    r0 = <error> :: int
-    r1 = <error> :: str
-    r2 = f(4, r0, r1)
-    r3 = <error> :: str
-    r4 = f(12, 6, r3)
-    return 1
-
-[case testMethodCallWithDefaultArgs]
-class A:
-    def f(self, x: int, y: int = 3, z: str = "test") -> None:
-        return None
-
-def g() -> None:
-    a = A()
-    a.f(2)
-    a.f(y = 3, x = 6)
-[out]
-def A.f(self, x, y, z):
-    self :: __main__.A
-    x, y :: int
-    z, r0 :: str
-L0:
-    if is_error(y) goto L1 else goto L2
-L1:
-    y = 6
-L2:
-    if is_error(z) goto L3 else goto L4
-L3:
-    r0 = 'test'
-    z = r0
-L4:
-    return 1
-def g():
-    r0, a :: __main__.A
-    r1 :: int
-    r2 :: str
-    r3 :: None
-    r4 :: str
-    r5 :: None
-L0:
-    r0 = A()
-    a = r0
-    r1 = <error> :: int
-    r2 = <error> :: str
-    r3 = a.f(4, r1, r2)
-    r4 = <error> :: str
-    r5 = a.f(12, 6, r4)
-    return 1
-
-[case testListComprehension]
-from typing import List
-
-def f() -> List[int]:
-    return [x*x for x in [1,2,3] if x != 2 if x != 3]
-[out]
-def f():
-    r0, r1 :: list
-    r2, r3, r4 :: object
-    r5 :: ptr
-    r6 :: short_int
-    r7 :: native_int
-    r8 :: short_int
-    r9 :: bit
-    r10 :: object
-    r11, x :: int
-    r12, r13 :: bit
-    r14 :: int
-    r15 :: object
-    r16 :: i32
-    r17 :: bit
-    r18 :: short_int
-L0:
-    r0 = PyList_New(0)
-    r1 = PyList_New(3)
-    r2 = object 1
-    r3 = object 2
-    r4 = object 3
-    r5 = list_items r1
-    buf_init_item r5, 0, r2
-    buf_init_item r5, 1, r3
-    buf_init_item r5, 2, r4
-    keep_alive r1
-    r6 = 0
-L1:
-    r7 = var_object_size r1
-    r8 = r7 << 1
-    r9 = int_lt r6, r8
-    if r9 goto L2 else goto L8 :: bool
-L2:
-    r10 = CPyList_GetItemUnsafe(r1, r6)
-    r11 = unbox(int, r10)
-    x = r11
-    r12 = int_ne x, 4
-    if r12 goto L4 else goto L3 :: bool
-L3:
-    goto L7
-L4:
-    r13 = int_ne x, 6
-    if r13 goto L6 else goto L5 :: bool
-L5:
-    goto L7
-L6:
-    r14 = CPyTagged_Multiply(x, x)
-    r15 = box(int, r14)
-    r16 = PyList_Append(r0, r15)
-    r17 = r16 >= 0 :: signed
-L7:
-    r18 = r6 + 2
-    r6 = r18
-    goto L1
-L8:
-    return r0
-
-[case testDictComprehension]
-from typing import Dict
-def f() -> Dict[int, int]:
-    return {x: x*x for x in [1,2,3] if x != 2 if x != 3}
-[out]
-def f():
-    r0 :: dict
-    r1 :: list
-    r2, r3, r4 :: object
-    r5 :: ptr
-    r6 :: short_int
-    r7 :: native_int
-    r8 :: short_int
-    r9 :: bit
-    r10 :: object
-    r11, x :: int
-    r12, r13 :: bit
-    r14 :: int
-    r15, r16 :: object
-    r17 :: i32
-    r18 :: bit
-    r19 :: short_int
-L0:
-    r0 = PyDict_New()
-    r1 = PyList_New(3)
-    r2 = object 1
-    r3 = object 2
-    r4 = object 3
-    r5 = list_items r1
-    buf_init_item r5, 0, r2
-    buf_init_item r5, 1, r3
-    buf_init_item r5, 2, r4
-    keep_alive r1
-    r6 = 0
-L1:
-    r7 = var_object_size r1
-    r8 = r7 << 1
-    r9 = int_lt r6, r8
-    if r9 goto L2 else goto L8 :: bool
-L2:
-    r10 = CPyList_GetItemUnsafe(r1, r6)
-    r11 = unbox(int, r10)
-    x = r11
-    r12 = int_ne x, 4
-    if r12 goto L4 else goto L3 :: bool
-L3:
-    goto L7
-L4:
-    r13 = int_ne x, 6
-    if r13 goto L6 else goto L5 :: bool
-L5:
-    goto L7
-L6:
-    r14 = CPyTagged_Multiply(x, x)
-    r15 = box(int, x)
-    r16 = box(int, r14)
-    r17 = CPyDict_SetItem(r0, r15, r16)
-    r18 = r17 >= 0 :: signed
-L7:
-    r19 = r6 + 2
-    r6 = r19
-    goto L1
-L8:
-    return r0
-
-[case testLoopsMultipleAssign]
-from typing import List, Tuple
-def f(l: List[Tuple[int, int, int]]) -> List[int]:
-    for x, y, z in l:
-        pass
-    return [x+y+z for x, y, z in l]
-[out]
-def f(l):
-    l :: list
-    r0 :: short_int
-    r1 :: native_int
-    r2 :: short_int
-    r3 :: bit
-    r4 :: object
-    r5 :: tuple[int, int, int]
-    r6, x, r7, y, r8, z :: int
-    r9 :: short_int
-    r10 :: native_int
-    r11 :: list
-    r12 :: short_int
-    r13 :: native_int
-    r14 :: short_int
-    r15 :: bit
-    r16 :: object
-    r17 :: tuple[int, int, int]
-    r18, x_2, r19, y_2, r20, z_2, r21, r22 :: int
-    r23 :: object
-    r24 :: bit
-    r25 :: short_int
-L0:
-    r0 = 0
-L1:
-    r1 = var_object_size l
-    r2 = r1 << 1
-    r3 = int_lt r0, r2
-    if r3 goto L2 else goto L4 :: bool
-L2:
-    r4 = CPyList_GetItemUnsafe(l, r0)
-    r5 = unbox(tuple[int, int, int], r4)
-    r6 = r5[0]
-    x = r6
-    r7 = r5[1]
-    y = r7
-    r8 = r5[2]
-    z = r8
-L3:
-    r9 = r0 + 2
-    r0 = r9
-    goto L1
-L4:
-    r10 = var_object_size l
-    r11 = PyList_New(r10)
-    r12 = 0
-L5:
-    r13 = var_object_size l
-    r14 = r13 << 1
-    r15 = int_lt r12, r14
-    if r15 goto L6 else goto L8 :: bool
-L6:
-    r16 = CPyList_GetItemUnsafe(l, r12)
-    r17 = unbox(tuple[int, int, int], r16)
-    r18 = r17[0]
-    x_2 = r18
-    r19 = r17[1]
-    y_2 = r19
-    r20 = r17[2]
-    z_2 = r20
-    r21 = CPyTagged_Add(x_2, y_2)
-    r22 = CPyTagged_Add(r21, z_2)
-    r23 = box(int, r22)
-    r24 = CPyList_SetItemUnsafe(r11, r12, r23)
-L7:
-    r25 = r12 + 2
-    r12 = r25
-    goto L5
-L8:
-    return r11
-
-[case testProperty]
-class PropertyHolder:
-    @property
-    def value(self) -> int:
-        return self.left + self.right if self.is_add else self.left - self.right
-    def __init__(self, left: int, right: int, is_add: bool) -> None:
-        self.left = left
-        self.right = right
-        self.is_add = is_add
-    def twice_value(self) -> int:
-        return 2 * self.value
-[out]
-def PropertyHolder.value(self):
-    self :: __main__.PropertyHolder
-    r0 :: bool
-    r1, r2, r3, r4, r5, r6, r7 :: int
-L0:
-    r0 = self.is_add
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    r1 = borrow self.left
-    r2 = borrow self.right
-    r3 = CPyTagged_Add(r1, r2)
-    keep_alive self, self
-    r4 = r3
-    goto L3
-L2:
-    r5 = borrow self.left
-    r6 = borrow self.right
-    r7 = CPyTagged_Subtract(r5, r6)
-    keep_alive self, self
-    r4 = r7
-L3:
-    return r4
-def PropertyHolder.__init__(self, left, right, is_add):
-    self :: __main__.PropertyHolder
-    left, right :: int
-    is_add :: bool
-L0:
-    self.left = left
-    self.right = right
-    self.is_add = is_add
-    return 1
-def PropertyHolder.twice_value(self):
-    self :: __main__.PropertyHolder
-    r0, r1 :: int
-L0:
-    r0 = self.value
-    r1 = CPyTagged_Multiply(4, r0)
-    return r1
-
-[case testNativeIndex]
-from typing import List
-class A:
-    def __getitem__(self, index: int) -> int: pass
-
-def g(a: A, b: List[int], c: int) -> int:
-    return a[c] + b[c]
-[out]
-def A.__getitem__(self, index):
-    self :: __main__.A
-    index :: int
-L0:
-    unreachable
-def g(a, b, c):
-    a :: __main__.A
-    b :: list
-    c, r0 :: int
-    r1 :: object
-    r2, r3 :: int
-L0:
-    r0 = a.__getitem__(c)
-    r1 = CPyList_GetItemBorrow(b, c)
-    r2 = unbox(int, r1)
-    r3 = CPyTagged_Add(r0, r2)
-    keep_alive b, c
-    return r3
-
-[case testTypeAlias_toplevel]
-from typing import List, NewType, NamedTuple
-Lol = NamedTuple('Lol', (('a', int), ('b', str)))
-x = Lol(1, '')
-Foo = List[int]
-Bar = NewType('Bar', Foo)
-y = Bar([1,2,3])
-[out]
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4, r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8 :: object
-    r9, r10 :: str
-    r11 :: object
-    r12 :: tuple[str, object]
-    r13 :: object
-    r14 :: str
-    r15 :: object
-    r16 :: tuple[str, object]
-    r17 :: object
-    r18 :: tuple[object, object]
-    r19 :: object
-    r20 :: dict
-    r21 :: str
-    r22, r23 :: object
-    r24 :: dict
-    r25 :: str
-    r26 :: i32
-    r27 :: bit
-    r28 :: str
-    r29 :: dict
-    r30 :: str
-    r31, r32, r33 :: object
-    r34 :: tuple
-    r35 :: dict
-    r36 :: str
-    r37 :: i32
-    r38 :: bit
-    r39 :: dict
-    r40 :: str
-    r41, r42, r43 :: object
-    r44 :: dict
-    r45 :: str
-    r46 :: i32
-    r47 :: bit
-    r48 :: str
-    r49 :: dict
-    r50 :: str
-    r51 :: object
-    r52 :: dict
-    r53 :: str
-    r54, r55 :: object
-    r56 :: dict
-    r57 :: str
-    r58 :: i32
-    r59 :: bit
-    r60 :: list
-    r61, r62, r63 :: object
-    r64 :: ptr
-    r65 :: dict
-    r66 :: str
-    r67 :: i32
-    r68 :: bit
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = ('List', 'NewType', 'NamedTuple')
-    r6 = 'typing'
-    r7 = __main__.globals :: static
-    r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)
-    typing = r8 :: module
-    r9 = 'Lol'
-    r10 = 'a'
-    r11 = load_address PyLong_Type
-    r12 = (r10, r11)
-    r13 = box(tuple[str, object], r12)
-    r14 = 'b'
-    r15 = load_address PyUnicode_Type
-    r16 = (r14, r15)
-    r17 = box(tuple[str, object], r16)
-    r18 = (r13, r17)
-    r19 = box(tuple[object, object], r18)
-    r20 = __main__.globals :: static
-    r21 = 'NamedTuple'
-    r22 = CPyDict_GetItem(r20, r21)
-    r23 = PyObject_CallFunctionObjArgs(r22, r9, r19, 0)
-    r24 = __main__.globals :: static
-    r25 = 'Lol'
-    r26 = CPyDict_SetItem(r24, r25, r23)
-    r27 = r26 >= 0 :: signed
-    r28 = ''
-    r29 = __main__.globals :: static
-    r30 = 'Lol'
-    r31 = CPyDict_GetItem(r29, r30)
-    r32 = object 1
-    r33 = PyObject_CallFunctionObjArgs(r31, r32, r28, 0)
-    r34 = cast(tuple, r33)
-    r35 = __main__.globals :: static
-    r36 = 'x'
-    r37 = CPyDict_SetItem(r35, r36, r34)
-    r38 = r37 >= 0 :: signed
-    r39 = __main__.globals :: static
-    r40 = 'List'
-    r41 = CPyDict_GetItem(r39, r40)
-    r42 = load_address PyLong_Type
-    r43 = PyObject_GetItem(r41, r42)
-    r44 = __main__.globals :: static
-    r45 = 'Foo'
-    r46 = CPyDict_SetItem(r44, r45, r43)
-    r47 = r46 >= 0 :: signed
-    r48 = 'Bar'
-    r49 = __main__.globals :: static
-    r50 = 'Foo'
-    r51 = CPyDict_GetItem(r49, r50)
-    r52 = __main__.globals :: static
-    r53 = 'NewType'
-    r54 = CPyDict_GetItem(r52, r53)
-    r55 = PyObject_CallFunctionObjArgs(r54, r48, r51, 0)
-    r56 = __main__.globals :: static
-    r57 = 'Bar'
-    r58 = CPyDict_SetItem(r56, r57, r55)
-    r59 = r58 >= 0 :: signed
-    r60 = PyList_New(3)
-    r61 = object 1
-    r62 = object 2
-    r63 = object 3
-    r64 = list_items r60
-    buf_init_item r64, 0, r61
-    buf_init_item r64, 1, r62
-    buf_init_item r64, 2, r63
-    keep_alive r60
-    r65 = __main__.globals :: static
-    r66 = 'y'
-    r67 = CPyDict_SetItem(r65, r66, r60)
-    r68 = r67 >= 0 :: signed
-    return 1
-
-[case testChainedConditional]
-def g(x: int) -> int:
-    return x
-def f(x: int, y: int, z: int) -> bool:
-    return g(x) < g(y) > g(z)
-[out]
-def g(x):
-    x :: int
-L0:
-    return x
-def f(x, y, z):
-    x, y, z, r0, r1 :: int
-    r2 :: bit
-    r3 :: bool
-    r4 :: int
-    r5 :: bit
-L0:
-    r0 = g(x)
-    r1 = g(y)
-    r2 = int_lt r0, r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = r2
-    goto L3
-L2:
-    r4 = g(z)
-    r5 = int_gt r1, r4
-    r3 = r5
-L3:
-    return r3
-
-[case testEq]
-class A:
-    def __eq__(self, x: object) -> bool:
-        return NotImplemented
-[out]
-def A.__eq__(self, x):
-    self :: __main__.A
-    x, r0 :: object
-L0:
-    r0 = load_address _Py_NotImplementedStruct
-    return r0
-def A.__ne__(__mypyc_self__, rhs):
-    __mypyc_self__ :: __main__.A
-    rhs, r0, r1 :: object
-    r2 :: bit
-    r3 :: i32
-    r4 :: bit
-    r5 :: bool
-    r6 :: object
-L0:
-    r0 = __mypyc_self__.__eq__(rhs)
-    r1 = load_address _Py_NotImplementedStruct
-    r2 = r0 == r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = PyObject_Not(r0)
-    r4 = r3 >= 0 :: signed
-    r5 = truncate r3: i32 to builtins.bool
-    r6 = box(bool, r5)
-    return r6
-L2:
-    return r1
-
-[case testDecorators_toplevel]
-from typing import Callable
-
-def a(f: Callable[[], None]) -> Callable[[], None]:
-    def g() -> None:
-        print('Entering')
-        f()
-        print('Exited')
-    return g
-
-def b(f: Callable[[], None]) -> Callable[[], None]:
-    def g() -> None:
-        print('---')
-        f()
-        print('---')
-    return g
-
-@a
-@b
-def c() -> None:
-    @a
-    @b
-    def d() -> None:
-        print('d')
-    print('c')
-    d()
-
-[out]
-def g_a_obj.__get__(__mypyc_self__, instance, owner):
-    __mypyc_self__, instance, owner, r0 :: object
-    r1 :: bit
-    r2 :: object
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = instance == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return __mypyc_self__
-L2:
-    r2 = PyMethod_New(__mypyc_self__, instance)
-    return r2
-def g_a_obj.__call__(__mypyc_self__):
-    __mypyc_self__ :: __main__.g_a_obj
-    r0 :: __main__.a_env
-    r1 :: str
-    r2 :: object
-    r3 :: str
-    r4, r5, r6, r7 :: object
-    r8 :: str
-    r9 :: object
-    r10 :: str
-    r11, r12 :: object
-L0:
-    r0 = __mypyc_self__.__mypyc_env__
-    r1 = 'Entering'
-    r2 = builtins :: module
-    r3 = 'print'
-    r4 = CPyObject_GetAttr(r2, r3)
-    r5 = PyObject_CallFunctionObjArgs(r4, r1, 0)
-    r6 = r0.f
-    r7 = PyObject_CallFunctionObjArgs(r6, 0)
-    r8 = 'Exited'
-    r9 = builtins :: module
-    r10 = 'print'
-    r11 = CPyObject_GetAttr(r9, r10)
-    r12 = PyObject_CallFunctionObjArgs(r11, r8, 0)
-    return 1
-def a(f):
-    f :: object
-    r0 :: __main__.a_env
-    r1 :: bool
-    r2 :: __main__.g_a_obj
-    r3 :: bool
-    g :: object
-L0:
-    r0 = a_env()
-    r0.f = f; r1 = is_error
-    r2 = g_a_obj()
-    r2.__mypyc_env__ = r0; r3 = is_error
-    g = r2
-    return g
-def g_b_obj.__get__(__mypyc_self__, instance, owner):
-    __mypyc_self__, instance, owner, r0 :: object
-    r1 :: bit
-    r2 :: object
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = instance == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return __mypyc_self__
-L2:
-    r2 = PyMethod_New(__mypyc_self__, instance)
-    return r2
-def g_b_obj.__call__(__mypyc_self__):
-    __mypyc_self__ :: __main__.g_b_obj
-    r0 :: __main__.b_env
-    r1 :: str
-    r2 :: object
-    r3 :: str
-    r4, r5, r6, r7 :: object
-    r8 :: str
-    r9 :: object
-    r10 :: str
-    r11, r12 :: object
-L0:
-    r0 = __mypyc_self__.__mypyc_env__
-    r1 = '---'
-    r2 = builtins :: module
-    r3 = 'print'
-    r4 = CPyObject_GetAttr(r2, r3)
-    r5 = PyObject_CallFunctionObjArgs(r4, r1, 0)
-    r6 = r0.f
-    r7 = PyObject_CallFunctionObjArgs(r6, 0)
-    r8 = '---'
-    r9 = builtins :: module
-    r10 = 'print'
-    r11 = CPyObject_GetAttr(r9, r10)
-    r12 = PyObject_CallFunctionObjArgs(r11, r8, 0)
-    return 1
-def b(f):
-    f :: object
-    r0 :: __main__.b_env
-    r1 :: bool
-    r2 :: __main__.g_b_obj
-    r3 :: bool
-    g :: object
-L0:
-    r0 = b_env()
-    r0.f = f; r1 = is_error
-    r2 = g_b_obj()
-    r2.__mypyc_env__ = r0; r3 = is_error
-    g = r2
-    return g
-def d_c_obj.__get__(__mypyc_self__, instance, owner):
-    __mypyc_self__, instance, owner, r0 :: object
-    r1 :: bit
-    r2 :: object
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = instance == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return __mypyc_self__
-L2:
-    r2 = PyMethod_New(__mypyc_self__, instance)
-    return r2
-def d_c_obj.__call__(__mypyc_self__):
-    __mypyc_self__ :: __main__.d_c_obj
-    r0 :: __main__.c_env
-    r1 :: str
-    r2 :: object
-    r3 :: str
-    r4, r5 :: object
-L0:
-    r0 = __mypyc_self__.__mypyc_env__
-    r1 = 'd'
-    r2 = builtins :: module
-    r3 = 'print'
-    r4 = CPyObject_GetAttr(r2, r3)
-    r5 = PyObject_CallFunctionObjArgs(r4, r1, 0)
-    return 1
-def c():
-    r0 :: __main__.c_env
-    r1 :: __main__.d_c_obj
-    r2 :: bool
-    r3 :: dict
-    r4 :: str
-    r5, r6 :: object
-    r7 :: dict
-    r8 :: str
-    r9, r10, d :: object
-    r11 :: dict
-    r12 :: str
-    r13 :: i32
-    r14 :: bit
-    r15 :: str
-    r16 :: object
-    r17 :: str
-    r18, r19, r20 :: object
-L0:
-    r0 = c_env()
-    r1 = d_c_obj()
-    r1.__mypyc_env__ = r0; r2 = is_error
-    r3 = __main__.globals :: static
-    r4 = 'b'
-    r5 = CPyDict_GetItem(r3, r4)
-    r6 = PyObject_CallFunctionObjArgs(r5, r1, 0)
-    r7 = __main__.globals :: static
-    r8 = 'a'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = PyObject_CallFunctionObjArgs(r9, r6, 0)
-    d = r10
-    r11 = __main__.globals :: static
-    r12 = 'd'
-    r13 = CPyDict_SetItem(r11, r12, r10)
-    r14 = r13 >= 0 :: signed
-    r15 = 'c'
-    r16 = builtins :: module
-    r17 = 'print'
-    r18 = CPyObject_GetAttr(r16, r17)
-    r19 = PyObject_CallFunctionObjArgs(r18, r15, 0)
-    r20 = PyObject_CallFunctionObjArgs(d, 0)
-    return 1
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4, r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8 :: object
-    r9 :: dict
-    r10 :: str
-    r11 :: object
-    r12 :: dict
-    r13 :: str
-    r14, r15 :: object
-    r16 :: dict
-    r17 :: str
-    r18, r19 :: object
-    r20 :: dict
-    r21 :: str
-    r22 :: i32
-    r23 :: bit
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = ('Callable',)
-    r6 = 'typing'
-    r7 = __main__.globals :: static
-    r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)
-    typing = r8 :: module
-    r9 = __main__.globals :: static
-    r10 = 'c'
-    r11 = CPyDict_GetItem(r9, r10)
-    r12 = __main__.globals :: static
-    r13 = 'b'
-    r14 = CPyDict_GetItem(r12, r13)
-    r15 = PyObject_CallFunctionObjArgs(r14, r11, 0)
-    r16 = __main__.globals :: static
-    r17 = 'a'
-    r18 = CPyDict_GetItem(r16, r17)
-    r19 = PyObject_CallFunctionObjArgs(r18, r15, 0)
-    r20 = __main__.globals :: static
-    r21 = 'c'
-    r22 = CPyDict_SetItem(r20, r21, r19)
-    r23 = r22 >= 0 :: signed
-    return 1
-
-[case testDecoratorsSimple_toplevel]
-from typing import Callable
-
-def a(f: Callable[[], None]) -> Callable[[], None]:
-    def g() -> None:
-        print('Entering')
-        f()
-        print('Exited')
-    return g
-
-[out]
-def g_a_obj.__get__(__mypyc_self__, instance, owner):
-    __mypyc_self__, instance, owner, r0 :: object
-    r1 :: bit
-    r2 :: object
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = instance == r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    return __mypyc_self__
-L2:
-    r2 = PyMethod_New(__mypyc_self__, instance)
-    return r2
-def g_a_obj.__call__(__mypyc_self__):
-    __mypyc_self__ :: __main__.g_a_obj
-    r0 :: __main__.a_env
-    r1 :: str
-    r2 :: object
-    r3 :: str
-    r4, r5, r6, r7 :: object
-    r8 :: str
-    r9 :: object
-    r10 :: str
-    r11, r12 :: object
-L0:
-    r0 = __mypyc_self__.__mypyc_env__
-    r1 = 'Entering'
-    r2 = builtins :: module
-    r3 = 'print'
-    r4 = CPyObject_GetAttr(r2, r3)
-    r5 = PyObject_CallFunctionObjArgs(r4, r1, 0)
-    r6 = r0.f
-    r7 = PyObject_CallFunctionObjArgs(r6, 0)
-    r8 = 'Exited'
-    r9 = builtins :: module
-    r10 = 'print'
-    r11 = CPyObject_GetAttr(r9, r10)
-    r12 = PyObject_CallFunctionObjArgs(r11, r8, 0)
-    return 1
-def a(f):
-    f :: object
-    r0 :: __main__.a_env
-    r1 :: bool
-    r2 :: __main__.g_a_obj
-    r3 :: bool
-    g :: object
-L0:
-    r0 = a_env()
-    r0.f = f; r1 = is_error
-    r2 = g_a_obj()
-    r2.__mypyc_env__ = r0; r3 = is_error
-    g = r2
-    return g
-def __top_level__():
-    r0, r1 :: object
-    r2 :: bit
-    r3 :: str
-    r4, r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8 :: object
-L0:
-    r0 = builtins :: module
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L2 else goto L1 :: bool
-L1:
-    r3 = 'builtins'
-    r4 = PyImport_Import(r3)
-    builtins = r4 :: module
-L2:
-    r5 = ('Callable',)
-    r6 = 'typing'
-    r7 = __main__.globals :: static
-    r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)
-    typing = r8 :: module
-    return 1
-
-[case testAnyAllG]
-from typing import Iterable
-
-def call_any(l: Iterable[int]) -> bool:
-    return any(i == 0 for i in l)
-
-def call_all(l: Iterable[int]) -> bool:
-    return all(i == 0 for i in l)
-
-[out]
-def call_any(l):
-    l :: object
-    r0 :: bool
-    r1, r2 :: object
-    r3, i :: int
-    r4, r5 :: bit
-L0:
-    r0 = 0
-    r1 = PyObject_GetIter(l)
-L1:
-    r2 = PyIter_Next(r1)
-    if is_error(r2) goto L6 else goto L2
-L2:
-    r3 = unbox(int, r2)
-    i = r3
-    r4 = int_eq i, 0
-    if r4 goto L3 else goto L4 :: bool
-L3:
-    r0 = 1
-    goto L8
-L4:
-L5:
-    goto L1
-L6:
-    r5 = CPy_NoErrOccured()
-L7:
-L8:
-    return r0
-def call_all(l):
-    l :: object
-    r0 :: bool
-    r1, r2 :: object
-    r3, i :: int
-    r4, r5, r6 :: bit
-L0:
-    r0 = 1
-    r1 = PyObject_GetIter(l)
-L1:
-    r2 = PyIter_Next(r1)
-    if is_error(r2) goto L6 else goto L2
-L2:
-    r3 = unbox(int, r2)
-    i = r3
-    r4 = int_eq i, 0
-    r5 = r4 ^ 1
-    if r5 goto L3 else goto L4 :: bool
-L3:
-    r0 = 0
-    goto L8
-L4:
-L5:
-    goto L1
-L6:
-    r6 = CPy_NoErrOccured()
-L7:
-L8:
-    return r0
-
-[case testSum]
-from typing import Callable, Iterable
-
-def call_sum(l: Iterable[int], comparison: Callable[[int], bool]) -> int:
-    return sum(comparison(x) for x in l)
-
-[out]
-def call_sum(l, comparison):
-    l, comparison :: object
-    r0 :: int
-    r1, r2 :: object
-    r3, x :: int
-    r4, r5 :: object
-    r6, r7 :: bool
-    r8, r9 :: int
-    r10 :: bit
-L0:
-    r0 = 0
-    r1 = PyObject_GetIter(l)
-L1:
-    r2 = PyIter_Next(r1)
-    if is_error(r2) goto L4 else goto L2
-L2:
-    r3 = unbox(int, r2)
-    x = r3
-    r4 = box(int, x)
-    r5 = PyObject_CallFunctionObjArgs(comparison, r4, 0)
-    r6 = unbox(bool, r5)
-    r7 = r6 << 1
-    r8 = extend r7: builtins.bool to builtins.int
-    r9 = CPyTagged_Add(r0, r8)
-    r0 = r9
-L3:
-    goto L1
-L4:
-    r10 = CPy_NoErrOccured()
-L5:
-    return r0
-
-[case testSetAttr1]
-from typing import Any, Dict, List
-def lol(x: Any):
-    setattr(x, 'x', '5')
-
-[out]
-def lol(x):
-    x :: object
-    r0, r1 :: str
-    r2 :: i32
-    r3 :: bit
-    r4 :: object
-L0:
-    r0 = 'x'
-    r1 = '5'
-    r2 = PyObject_SetAttr(x, r0, r1)
-    r3 = r2 >= 0 :: signed
-    r4 = box(None, 1)
-    return r4
-
-[case testFinalModuleInt]
-from typing import Final
-
-x: Final = 1
-y: Final = 2
-
-def f(a: bool) -> int:
-    if a:
-        return x
-    else:
-        return y
-[out]
-def f(a):
-    a :: bool
-L0:
-    if a goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 4
-L3:
-    unreachable
-
-[case testFinalModuleStr]
-from typing import Final
-
-x: Final = 'x'
-y: Final = 'y'
-
-def f(a: bool) -> str:
-    if a:
-        return x
-    else:
-        return y
-[out]
-def f(a):
-    a :: bool
-    r0, r1 :: str
-L0:
-    if a goto L1 else goto L2 :: bool
-L1:
-    r0 = 'x'
-    return r0
-L2:
-    r1 = 'y'
-    return r1
-L3:
-    unreachable
-
-[case testFinalModuleBool]
-from typing import Final
-
-x: Final = True
-y: Final = False
-
-def f(a: bool) -> bool:
-    if a:
-        return x
-    else:
-        return y
-[out]
-def f(a):
-    a :: bool
-L0:
-    if a goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-L3:
-    unreachable
-
-[case testFinalClass]
-from typing import Final
-
-class C:
-    x: Final = 1
-    y: Final = 2
-
-def f(a: bool) -> int:
-    if a:
-        return C.x
-    else:
-        return C.y
-[out]
-def C.__mypyc_defaults_setup(__mypyc_self__):
-    __mypyc_self__ :: __main__.C
-L0:
-    __mypyc_self__.x = 2
-    __mypyc_self__.y = 4
-    return 1
-def f(a):
-    a :: bool
-L0:
-    if a goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 4
-L3:
-    unreachable
-
-[case testFinalStaticList]
-from typing import Final
-
-x: Final = [1]
-
-def f() -> int:
-    return x[0]
-[out]
-def f():
-    r0 :: list
-    r1 :: bool
-    r2 :: object
-    r3 :: int
-L0:
-    r0 = __main__.x :: static
-    if is_error(r0) goto L1 else goto L2
-L1:
-    r1 = raise NameError('value for final name "x" was not set')
-    unreachable
-L2:
-    r2 = CPyList_GetItemShort(r0, 0)
-    r3 = unbox(int, r2)
-    return r3
-
-[case testFinalStaticTuple]
-from typing import Final
-
-x: Final = (1, 2)
-
-def f() -> int:
-    return x[0]
-[out]
-def f():
-    r0 :: tuple[int, int]
-    r1 :: bool
-    r2 :: int
-L0:
-    r0 = __main__.x :: static
-    if is_error(r0) goto L1 else goto L2
-L1:
-    r1 = raise NameError('value for final name "x" was not set')
-    unreachable
-L2:
-    r2 = r0[0]
-    return r2
-
-[case testFinalStaticInt]
-from typing import Final
-
-x: Final = 1 + int()
-
-def f() -> int:
-    return x - 1
-[out]
-def f():
-    r0 :: int
-    r1 :: bool
-    r2 :: int
-L0:
-    r0 = __main__.x :: static
-    if is_error(r0) goto L1 else goto L2
-L1:
-    r1 = raise NameError('value for final name "x" was not set')
-    unreachable
-L2:
-    r2 = CPyTagged_Subtract(r0, 2)
-    return r2
-
-[case testFinalRestrictedTypeVar]
-from typing import TypeVar
-if False:
-    from typing import Final
-
-FOO = 10  # type: Final
-
-Targ = TypeVar('Targ', int, str)
-def foo(z: Targ) -> None:
-    FOO
-[out]
-def foo(z):
-    z :: object
-L0:
-    return 1
-
-[case testFinalLocals]
-from typing import Final
-
-def inlined() -> str:
-    # XXX: the final type must be declared explicitly for Var.final_value to be set.
-    const: Final[str] = "Oppenheimer"
-    return const
-
-def local() -> str:
-    const: Final[str] = inlined()
-    return const
-[out]
-def inlined():
-    r0, const, r1 :: str
-L0:
-    r0 = 'Oppenheimer'
-    const = r0
-    r1 = 'Oppenheimer'
-    return r1
-def local():
-    r0, const :: str
-L0:
-    r0 = inlined()
-    const = r0
-    return const
-
-[case testDirectlyCall__bool__]
-class A:
-    def __bool__(self) -> bool:
-        return True
-class B(A):
-    def __bool__(self) -> bool:
-        return False
-
-def lol(x: A) -> int:
-    if x:
-        return 1
-    else:
-        return 0
-
-[out]
-def A.__bool__(self):
-    self :: __main__.A
-L0:
-    return 1
-def B.__bool__(self):
-    self :: __main__.B
-L0:
-    return 0
-def lol(x):
-    x :: __main__.A
-    r0 :: bool
-L0:
-    r0 = x.__bool__()
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 0
-L3:
-    unreachable
-
-[case testRevealType]
-def f(x: int) -> None:
-    reveal_type(x)  # type: ignore
-[out]
-def f(x):
-    x :: int
-    r0 :: object
-    r1 :: str
-    r2, r3, r4 :: object
-L0:
-    r0 = builtins :: module
-    r1 = 'reveal_type'
-    r2 = CPyObject_GetAttr(r0, r1)
-    r3 = box(int, x)
-    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
-    return 1
-
-[case testCallCWithStrJoinMethod]
-from typing import List
-def f(x: str, y: List[str]) -> str:
-    return x.join(y)
-[out]
-def f(x, y):
-    x :: str
-    y :: list
-    r0 :: str
-L0:
-    r0 = PyUnicode_Join(x, y)
-    return r0
-
-[case testCallCWithToListFunction]
-from typing import List, Iterable, Tuple, Dict
-# generic object
-def f(x: Iterable[int]) -> List[int]:
-    return list(x)
-
-# need coercing
-def g(x: Tuple[int, int, int]) -> List[int]:
-    return list(x)
-
-# non-list object
-def h(x: Dict[int, str]) -> List[int]:
-    return list(x)
-
-[out]
-def f(x):
-    x :: object
-    r0 :: list
-L0:
-    r0 = PySequence_List(x)
-    return r0
-def g(x):
-    x :: tuple[int, int, int]
-    r0 :: object
-    r1 :: list
-L0:
-    r0 = box(tuple[int, int, int], x)
-    r1 = PySequence_List(r0)
-    return r1
-def h(x):
-    x :: dict
-    r0 :: list
-L0:
-    r0 = PySequence_List(x)
-    return r0
-
-[case testBoolFunction]
-def f(x: object) -> bool:
-    return bool(x)
-[out]
-def f(x):
-    x :: object
-    r0 :: i32
-    r1 :: bit
-    r2 :: bool
-L0:
-    r0 = PyObject_IsTrue(x)
-    r1 = r0 >= 0 :: signed
-    r2 = truncate r0: i32 to builtins.bool
-    return r2
-
-[case testLocalImports]
-def root() -> None:
-    import dataclasses
-    import enum
-
-def submodule() -> int:
-    import p.m
-    return p.x
-[file p/__init__.py]
-x = 1
-[file p/m.py]
-[out]
-def root():
-    r0 :: dict
-    r1, r2 :: object
-    r3 :: bit
-    r4 :: str
-    r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8 :: str
-    r9 :: object
-    r10 :: i32
-    r11 :: bit
-    r12 :: dict
-    r13, r14 :: object
-    r15 :: bit
-    r16 :: str
-    r17 :: object
-    r18 :: str
-    r19 :: dict
-    r20 :: str
-    r21 :: object
-    r22 :: i32
-    r23 :: bit
-L0:
-    r0 = __main__.globals :: static
-    r1 = dataclasses :: module
-    r2 = load_address _Py_NoneStruct
-    r3 = r1 != r2
-    if r3 goto L2 else goto L1 :: bool
-L1:
-    r4 = 'dataclasses'
-    r5 = PyImport_Import(r4)
-    dataclasses = r5 :: module
-L2:
-    r6 = 'dataclasses'
-    r7 = PyImport_GetModuleDict()
-    r8 = 'dataclasses'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = CPyDict_SetItem(r0, r6, r9)
-    r11 = r10 >= 0 :: signed
-    r12 = __main__.globals :: static
-    r13 = enum :: module
-    r14 = load_address _Py_NoneStruct
-    r15 = r13 != r14
-    if r15 goto L4 else goto L3 :: bool
-L3:
-    r16 = 'enum'
-    r17 = PyImport_Import(r16)
-    enum = r17 :: module
-L4:
-    r18 = 'enum'
-    r19 = PyImport_GetModuleDict()
-    r20 = 'enum'
-    r21 = CPyDict_GetItem(r19, r20)
-    r22 = CPyDict_SetItem(r12, r18, r21)
-    r23 = r22 >= 0 :: signed
-    return 1
-def submodule():
-    r0 :: dict
-    r1, r2 :: object
-    r3 :: bit
-    r4 :: str
-    r5 :: object
-    r6 :: str
-    r7 :: dict
-    r8 :: str
-    r9 :: object
-    r10 :: i32
-    r11 :: bit
-    r12 :: dict
-    r13 :: str
-    r14 :: object
-    r15 :: str
-    r16 :: object
-    r17 :: int
-L0:
-    r0 = __main__.globals :: static
-    r1 = p.m :: module
-    r2 = load_address _Py_NoneStruct
-    r3 = r1 != r2
-    if r3 goto L2 else goto L1 :: bool
-L1:
-    r4 = 'p.m'
-    r5 = PyImport_Import(r4)
-    p.m = r5 :: module
-L2:
-    r6 = 'p'
-    r7 = PyImport_GetModuleDict()
-    r8 = 'p'
-    r9 = CPyDict_GetItem(r7, r8)
-    r10 = CPyDict_SetItem(r0, r6, r9)
-    r11 = r10 >= 0 :: signed
-    r12 = PyImport_GetModuleDict()
-    r13 = 'p'
-    r14 = CPyDict_GetItem(r12, r13)
-    r15 = 'x'
-    r16 = CPyObject_GetAttr(r14, r15)
-    r17 = unbox(int, r16)
-    return r17
-
-[case testIsinstanceBool]
-def f(x: object) -> bool:
-    return isinstance(x, bool)
-[out]
-def f(x):
-    x, r0 :: object
-    r1 :: i32
-    r2 :: bit
-    r3 :: bool
-L0:
-    r0 = load_address PyBool_Type
-    r1 = PyObject_IsInstance(x, r0)
-    r2 = r1 >= 0 :: signed
-    r3 = truncate r1: i32 to builtins.bool
-    return r3
-
-[case testRangeObject]
-def range_object() -> None:
-    r = range(4, 12, 2)
-    sum = 0
-    for i in r:
-        sum += i
-
-def range_in_loop() -> None:
-    sum = 0
-    for i in range(4, 12, 2):
-        sum += i
-[out]
-def range_object():
-    r0, r1, r2, r3, r4 :: object
-    r5, r :: range
-    sum :: int
-    r6, r7 :: object
-    r8, i, r9 :: int
-    r10 :: bit
-L0:
-    r0 = load_address PyRange_Type
-    r1 = object 4
-    r2 = object 12
-    r3 = object 2
-    r4 = PyObject_CallFunctionObjArgs(r0, r1, r2, r3, 0)
-    r5 = cast(range, r4)
-    r = r5
-    sum = 0
-    r6 = PyObject_GetIter(r)
-L1:
-    r7 = PyIter_Next(r6)
-    if is_error(r7) goto L4 else goto L2
-L2:
-    r8 = unbox(int, r7)
-    i = r8
-    r9 = CPyTagged_Add(sum, i)
-    sum = r9
-L3:
-    goto L1
-L4:
-    r10 = CPy_NoErrOccured()
-L5:
-    return 1
-def range_in_loop():
-    sum :: int
-    r0 :: short_int
-    i :: int
-    r1 :: bit
-    r2 :: int
-    r3 :: short_int
-L0:
-    sum = 0
-    r0 = 8
-    i = r0
-L1:
-    r1 = int_lt r0, 24
-    if r1 goto L2 else goto L4 :: bool
-L2:
-    r2 = CPyTagged_Add(sum, i)
-    sum = r2
-L3:
-    r3 = r0 + 4
-    r0 = r3
-    i = r3
-    goto L1
-L4:
-    return 1
-
-[case testLocalRedefinition]
-# mypy: allow-redefinition
-def f() -> None:
-    i = 0
-    i += 1
-    i = "foo"
-    i += i
-    i = 0.0
-[out]
-def f():
-    i, r0 :: int
-    r1, i__redef__, r2 :: str
-    i__redef____redef__ :: float
-L0:
-    i = 0
-    r0 = CPyTagged_Add(i, 2)
-    i = r0
-    r1 = 'foo'
-    i__redef__ = r1
-    r2 = CPyStr_Append(i__redef__, i__redef__)
-    i__redef__ = r2
-    i__redef____redef__ = 0.0
-    return 1
-
-[case testNewType]
-from typing import NewType
-
-class A: pass
-
-N = NewType("N", A)
-
-def f(arg: A) -> N:
-    return N(arg)
-[out]
-def f(arg):
-    arg :: __main__.A
-L0:
-    return arg
-
-[case testTypeCheckingFlag]
-from typing import TYPE_CHECKING, List
-
-def f(arg: List[int]) -> int:
-    if TYPE_CHECKING:
-        from collections.abc import Sized
-    s: Sized = arg
-    return len(s)
-
-[out]
-def f(arg):
-    arg :: list
-    r0 :: bool
-    r1 :: int
-    r2 :: bit
-    s :: object
-    r3 :: int
-L0:
-    r0 = 0 << 1
-    r1 = extend r0: builtins.bool to builtins.int
-    r2 = r1 != 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    goto L3
-L2:
-L3:
-    s = arg
-    r3 = CPyObject_Size(s)
-    return r3