[case testTupleGet]
from typing import Tuple

def f(x: Tuple[Tuple[int, bool], bool]) -> int:
    return x[0][0]
[out]
def f(x):
    x :: tuple[tuple[int, bool], bool]
    r0 :: tuple[int, bool]
    r1 :: int
L0:
    r0 = x[0]
    r1 = r0[0]
    return r1

[case testTupleNew]
from typing import Tuple

def f() -> int:
    t = (True, 1)
    return t[1]
[out]
def f():
    r0, t :: tuple[bool, int]
    r1 :: int
L0:
    r0 = (1, 2)
    t = r0
    r1 = t[1]
    return r1

[case testTupleLen]
from typing import Tuple
def f(x: Tuple[bool, bool, int]) -> int:
    return len(x)
[out]
def f(x):
    x :: tuple[bool, bool, int]
L0:
    return 6

[case testSequenceTuple]
from typing import List
def f(x: List[bool]) -> bool:
    return tuple(x)[1]
[out]
def f(x):
    x :: list
    r0 :: tuple
    r1 :: object
    r2 :: bool
L0:
    r0 = PyList_AsTuple(x)
    r1 = CPySequenceTuple_GetItem(r0, 2)
    r2 = unbox(bool, r1)
    return r2

[case testSequenceTupleLen]
from typing import Tuple
def f(x: Tuple[int, ...]) -> int:
  return len(x)
[out]
def f(x):
    x :: tuple
    r0 :: native_int
    r1 :: short_int
L0:
    r0 = var_object_size x
    r1 = r0 << 1
    return r1

[case testSequenceTupleForced]
from typing import Tuple
def f() -> int:
    t = (1, 2) # type: Tuple[int, ...]
    return t[1]
[out]
def f():
    r0 :: tuple[int, int]
    r1 :: object
    t :: tuple
    r2 :: object
    r3 :: int
L0:
    r0 = (2, 4)
    r1 = box(tuple[int, int], r0)
    t = r1
    r2 = CPySequenceTuple_GetItem(t, 2)
    r3 = unbox(int, r2)
    return r3

[case testTupleDisplay]
from typing import Sequence, Tuple
def f(x: Sequence[int], y: Sequence[int]) -> Tuple[int, ...]:
    return (1, 2, *x, *y, 3)
[out]
def f(x, y):
    x, y :: object
    r0 :: list
    r1, r2 :: object
    r3 :: ptr
    r4, r5, r6 :: object
    r7 :: i32
    r8 :: bit
    r9 :: tuple
L0:
    r0 = PyList_New(2)
    r1 = object 1
    r2 = object 2
    r3 = list_items r0
    buf_init_item r3, 0, r1
    buf_init_item r3, 1, r2
    keep_alive r0
    r4 = CPyList_Extend(r0, x)
    r5 = CPyList_Extend(r0, y)
    r6 = object 3
    r7 = PyList_Append(r0, r6)
    r8 = r7 >= 0 :: signed
    r9 = PyList_AsTuple(r0)
    return r9

[case testTupleFor]
from typing import Tuple, List
def f(xs: Tuple[str, ...]) -> None:
    for x in xs:
        pass
[out]
def f(xs):
    xs :: tuple
    r0 :: short_int
    r1 :: native_int
    r2 :: short_int
    r3 :: bit
    r4 :: object
    r5, x :: str
    r6 :: short_int
L0:
    r0 = 0
L1:
    r1 = var_object_size xs
    r2 = r1 << 1
    r3 = int_lt r0, r2
    if r3 goto L2 else goto L4 :: bool
L2:
    r4 = CPySequenceTuple_GetItem(xs, r0)
    r5 = cast(str, r4)
    x = r5
L3:
    r6 = r0 + 2
    r0 = r6
    goto L1
L4:
    return 1

[case testNamedTupleAttribute]
from typing import NamedTuple

NT = NamedTuple('NT', [('x', int), ('y', int)])

def f(nt: NT, b: bool) -> int:
    if b:
        return nt.x
    return nt.y
[out]
def f(nt, b):
    nt :: tuple
    b :: bool
    r0 :: object
    r1 :: int
    r2 :: object
    r3 :: int
L0:
    if b goto L1 else goto L2 :: bool
L1:
    r0 = CPySequenceTuple_GetItem(nt, 0)
    r1 = unbox(int, r0)
    return r1
L2:
    r2 = CPySequenceTuple_GetItem(nt, 2)
    r3 = unbox(int, r2)
    return r3


[case testTupleOperatorIn]
def f(i: int) -> bool:
    return i in [1, 2, 3]
[out]
def f(i):
    i :: int
    r0 :: bit
    r1 :: bool
    r2 :: bit
    r3 :: bool
    r4 :: bit
L0:
    r0 = int_eq i, 2
    if r0 goto L1 else goto L2 :: bool
L1:
    r1 = r0
    goto L3
L2:
    r2 = int_eq i, 4
    r1 = r2
L3:
    if r1 goto L4 else goto L5 :: bool
L4:
    r3 = r1
    goto L6
L5:
    r4 = int_eq i, 6
    r3 = r4
L6:
    return r3

[case testTupleBuiltFromList]
def f(val: int) -> bool:
    return val % 2 == 0

def test() -> None:
    source = [1, 2, 3]
    a = tuple(f(x) for x in source)
[out]
def f(val):
    val, r0 :: int
    r1 :: bit
L0:
    r0 = CPyTagged_Remainder(val, 4)
    r1 = int_eq r0, 0
    return r1
def test():
    r0 :: list
    r1, r2, r3 :: object
    r4 :: ptr
    source :: list
    r5 :: native_int
    r6 :: tuple
    r7 :: short_int
    r8 :: native_int
    r9 :: short_int
    r10 :: bit
    r11 :: object
    r12, x :: int
    r13 :: bool
    r14 :: object
    r15 :: bit
    r16 :: short_int
    a :: tuple
L0:
    r0 = PyList_New(3)
    r1 = object 1
    r2 = object 2
    r3 = object 3
    r4 = list_items r0
    buf_init_item r4, 0, r1
    buf_init_item r4, 1, r2
    buf_init_item r4, 2, r3
    keep_alive r0
    source = r0
    r5 = var_object_size source
    r6 = PyTuple_New(r5)
    r7 = 0
L1:
    r8 = var_object_size source
    r9 = r8 << 1
    r10 = int_lt r7, r9
    if r10 goto L2 else goto L4 :: bool
L2:
    r11 = CPyList_GetItemUnsafe(source, r7)
    r12 = unbox(int, r11)
    x = r12
    r13 = f(x)
    r14 = box(bool, r13)
    r15 = CPySequenceTuple_SetItemUnsafe(r6, r7, r14)
L3:
    r16 = r7 + 2
    r7 = r16
    goto L1
L4:
    a = r6
    return 1

[case testTupleBuiltFromStr]
def f2(val: str) -> str:
    return val + "f2"

def test() -> None:
    source = "abc"
    a = tuple(f2(x) for x in source)
[out]
def f2(val):
    val, r0, r1 :: str
L0:
    r0 = 'f2'
    r1 = PyUnicode_Concat(val, r0)
    return r1
def test():
    r0, source :: str
    r1 :: native_int
    r2 :: bit
    r3 :: tuple
    r4 :: short_int
    r5 :: native_int
    r6 :: bit
    r7 :: short_int
    r8 :: bit
    r9, x, r10 :: str
    r11 :: bit
    r12 :: short_int
    a :: tuple
L0:
    r0 = 'abc'
    source = r0
    r1 = CPyStr_Size_size_t(source)
    r2 = r1 >= 0 :: signed
    r3 = PyTuple_New(r1)
    r4 = 0
L1:
    r5 = CPyStr_Size_size_t(source)
    r6 = r5 >= 0 :: signed
    r7 = r5 << 1
    r8 = int_lt r4, r7
    if r8 goto L2 else goto L4 :: bool
L2:
    r9 = CPyStr_GetItem(source, r4)
    x = r9
    r10 = f2(x)
    r11 = CPySequenceTuple_SetItemUnsafe(r3, r4, r10)
L3:
    r12 = r4 + 2
    r4 = r12
    goto L1
L4:
    a = r3
    return 1

[case testTupleBuiltFromVariableLengthTuple]
from typing import Tuple

def f(val: bool) -> bool:
    return not val

def test(source: Tuple[bool, ...]) -> None:
    a = tuple(f(x) for x in source)
[out]
def f(val):
    val, r0 :: bool
L0:
    r0 = val ^ 1
    return r0
def test(source):
    source :: tuple
    r0 :: native_int
    r1 :: tuple
    r2 :: short_int
    r3 :: native_int
    r4 :: short_int
    r5 :: bit
    r6 :: object
    r7, x, r8 :: bool
    r9 :: object
    r10 :: bit
    r11 :: short_int
    a :: tuple
L0:
    r0 = var_object_size source
    r1 = PyTuple_New(r0)
    r2 = 0
L1:
    r3 = var_object_size source
    r4 = r3 << 1
    r5 = int_lt r2, r4
    if r5 goto L2 else goto L4 :: bool
L2:
    r6 = CPySequenceTuple_GetItem(source, r2)
    r7 = unbox(bool, r6)
    x = r7
    r8 = f(x)
    r9 = box(bool, r8)
    r10 = CPySequenceTuple_SetItemUnsafe(r1, r2, r9)
L3:
    r11 = r2 + 2
    r2 = r11
    goto L1
L4:
    a = r1
    return 1