[case testDictGet]
from typing import Dict
def f(d: Dict[int, bool]) -> bool:
    return d[0]
[out]
def f(d):
    d :: dict
    r0, r1 :: object
    r2 :: bool
L0:
    r0 = object 0
    r1 = CPyDict_GetItem(d, r0)
    r2 = unbox(bool, r1)
    return r2

[case testDictSet]
from typing import Dict
def f(d: Dict[int, bool]) -> None:
    d[0] = False
[out]
def f(d):
    d :: dict
    r0, r1 :: object
    r2 :: i32
    r3 :: bit
L0:
    r0 = object 0
    r1 = box(bool, 0)
    r2 = CPyDict_SetItem(d, r0, r1)
    r3 = r2 >= 0 :: signed
    return 1

[case testNewEmptyDict]
from typing import Dict
def f() -> None:
    d = {}  # type: Dict[bool, int]
[out]
def f():
    r0, d :: dict
L0:
    r0 = PyDict_New()
    d = r0
    return 1

[case testNewEmptyDictViaFunc]
from typing import Dict
def f() -> None:
    d: Dict[bool, int] = dict()

[out]
def f():
    r0, d :: dict
L0:
    r0 = PyDict_New()
    d = r0
    return 1

[case testNewDictWithValues]
def f(x: object) -> None:
    d = {1: 2, '': x}
[out]
def f(x):
    x :: object
    r0 :: str
    r1, r2 :: object
    r3, d :: dict
L0:
    r0 = ''
    r1 = object 1
    r2 = object 2
    r3 = CPyDict_Build(2, r1, r2, r0, x)
    d = r3
    return 1

[case testInDict]
from typing import Dict
def f(d: Dict[int, int]) -> bool:
    if 4 in d:
        return True
    else:
        return False
[out]
def f(d):
    d :: dict
    r0 :: object
    r1 :: i32
    r2 :: bit
    r3 :: bool
L0:
    r0 = object 4
    r1 = PyDict_Contains(d, r0)
    r2 = r1 >= 0 :: signed
    r3 = truncate r1: i32 to builtins.bool
    if r3 goto L1 else goto L2 :: bool
L1:
    return 1
L2:
    return 0
L3:
    unreachable

[case testNotInDict]
from typing import Dict
def f(d: Dict[int, int]) -> bool:
    if 4 not in d:
        return True
    else:
        return False
[out]
def f(d):
    d :: dict
    r0 :: object
    r1 :: i32
    r2 :: bit
    r3, r4 :: bool
L0:
    r0 = object 4
    r1 = PyDict_Contains(d, r0)
    r2 = r1 >= 0 :: signed
    r3 = truncate r1: i32 to builtins.bool
    r4 = r3 ^ 1
    if r4 goto L1 else goto L2 :: bool
L1:
    return 1
L2:
    return 0
L3:
    unreachable

[case testDictUpdate]
from typing import Dict
def f(a: Dict[int, int], b: Dict[int, int]) -> None:
    a.update(b)
[out]
def f(a, b):
    a, b :: dict
    r0 :: i32
    r1 :: bit
L0:
    r0 = CPyDict_Update(a, b)
    r1 = r0 >= 0 :: signed
    return 1

[case testDictKeyLvalue]
from typing import Dict
def increment(d: Dict[str, int]) -> Dict[str, int]:
    for k in d:
        d[k] += 1
    return d
[out]
def increment(d):
    d :: dict
    r0 :: short_int
    r1 :: native_int
    r2 :: short_int
    r3 :: object
    r4 :: tuple[bool, short_int, object]
    r5 :: short_int
    r6 :: bool
    r7 :: object
    r8, k :: str
    r9, r10, r11 :: object
    r12 :: i32
    r13, r14, r15 :: bit
L0:
    r0 = 0
    r1 = PyDict_Size(d)
    r2 = r1 << 1
    r3 = CPyDict_GetKeysIter(d)
L1:
    r4 = CPyDict_NextKey(r3, r0)
    r5 = r4[1]
    r0 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L4 :: bool
L2:
    r7 = r4[2]
    r8 = cast(str, r7)
    k = r8
    r9 = CPyDict_GetItem(d, k)
    r10 = object 1
    r11 = PyNumber_InPlaceAdd(r9, r10)
    r12 = CPyDict_SetItem(d, k, r11)
    r13 = r12 >= 0 :: signed
L3:
    r14 = CPyDict_CheckSize(d, r2)
    goto L1
L4:
    r15 = CPy_NoErrOccured()
L5:
    return d

[case testDictDisplay]
from typing import Dict
def f(x: str, y: Dict[str, int]) -> Dict[str, int]:
    return {x: 2, **y, 'z': 3}
[out]
def f(x, y):
    x :: str
    y :: dict
    r0 :: str
    r1 :: object
    r2 :: dict
    r3 :: i32
    r4 :: bit
    r5 :: object
    r6 :: i32
    r7 :: bit
L0:
    r0 = 'z'
    r1 = object 2
    r2 = CPyDict_Build(1, x, r1)
    r3 = CPyDict_UpdateInDisplay(r2, y)
    r4 = r3 >= 0 :: signed
    r5 = object 3
    r6 = CPyDict_SetItem(r2, r0, r5)
    r7 = r6 >= 0 :: signed
    return r2

[case testDictIterationMethods]
from typing import Dict, Union
from typing_extensions import TypedDict

class Person(TypedDict):
    name: str
    age: int

def print_dict_methods(d1: Dict[int, int], d2: Dict[int, int]) -> None:
    for v in d1.values():
        if v in d2:
            return
    for k, v in d2.items():
        d2[k] += v
def union_of_dicts(d: Union[Dict[str, int], Dict[str, str]]) -> None:
    new = {}
    for k, v in d.items():
        new[k] = int(v)
def typeddict(d: Person) -> None:
    for k, v in d.items():
        if k == "name":
            name = v
[out]
def print_dict_methods(d1, d2):
    d1, d2 :: dict
    r0 :: short_int
    r1 :: native_int
    r2 :: short_int
    r3 :: object
    r4 :: tuple[bool, short_int, object]
    r5 :: short_int
    r6 :: bool
    r7 :: object
    r8, v :: int
    r9 :: object
    r10 :: i32
    r11 :: bit
    r12 :: bool
    r13, r14 :: bit
    r15 :: short_int
    r16 :: native_int
    r17 :: short_int
    r18 :: object
    r19 :: tuple[bool, short_int, object, object]
    r20 :: short_int
    r21 :: bool
    r22, r23 :: object
    r24, r25, k :: int
    r26, r27, r28, r29, r30 :: object
    r31 :: i32
    r32, r33, r34 :: bit
L0:
    r0 = 0
    r1 = PyDict_Size(d1)
    r2 = r1 << 1
    r3 = CPyDict_GetValuesIter(d1)
L1:
    r4 = CPyDict_NextValue(r3, r0)
    r5 = r4[1]
    r0 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L6 :: bool
L2:
    r7 = r4[2]
    r8 = unbox(int, r7)
    v = r8
    r9 = box(int, v)
    r10 = PyDict_Contains(d2, r9)
    r11 = r10 >= 0 :: signed
    r12 = truncate r10: i32 to builtins.bool
    if r12 goto L3 else goto L4 :: bool
L3:
    return 1
L4:
L5:
    r13 = CPyDict_CheckSize(d1, r2)
    goto L1
L6:
    r14 = CPy_NoErrOccured()
L7:
    r15 = 0
    r16 = PyDict_Size(d2)
    r17 = r16 << 1
    r18 = CPyDict_GetItemsIter(d2)
L8:
    r19 = CPyDict_NextItem(r18, r15)
    r20 = r19[1]
    r15 = r20
    r21 = r19[0]
    if r21 goto L9 else goto L11 :: bool
L9:
    r22 = r19[2]
    r23 = r19[3]
    r24 = unbox(int, r22)
    r25 = unbox(int, r23)
    k = r24
    v = r25
    r26 = box(int, k)
    r27 = CPyDict_GetItem(d2, r26)
    r28 = box(int, v)
    r29 = PyNumber_InPlaceAdd(r27, r28)
    r30 = box(int, k)
    r31 = CPyDict_SetItem(d2, r30, r29)
    r32 = r31 >= 0 :: signed
L10:
    r33 = CPyDict_CheckSize(d2, r17)
    goto L8
L11:
    r34 = CPy_NoErrOccured()
L12:
    return 1
def union_of_dicts(d):
    d, r0, new :: dict
    r1 :: short_int
    r2 :: native_int
    r3 :: short_int
    r4 :: object
    r5 :: tuple[bool, short_int, object, object]
    r6 :: short_int
    r7 :: bool
    r8, r9 :: object
    r10 :: str
    r11 :: union[int, str]
    k :: str
    v :: union[int, str]
    r12, r13 :: object
    r14 :: int
    r15 :: object
    r16 :: i32
    r17, r18, r19 :: bit
L0:
    r0 = PyDict_New()
    new = r0
    r1 = 0
    r2 = PyDict_Size(d)
    r3 = r2 << 1
    r4 = CPyDict_GetItemsIter(d)
L1:
    r5 = CPyDict_NextItem(r4, r1)
    r6 = r5[1]
    r1 = r6
    r7 = r5[0]
    if r7 goto L2 else goto L4 :: bool
L2:
    r8 = r5[2]
    r9 = r5[3]
    r10 = cast(str, r8)
    r11 = cast(union[int, str], r9)
    k = r10
    v = r11
    r12 = load_address PyLong_Type
    r13 = PyObject_CallFunctionObjArgs(r12, v, 0)
    r14 = unbox(int, r13)
    r15 = box(int, r14)
    r16 = CPyDict_SetItem(new, k, r15)
    r17 = r16 >= 0 :: signed
L3:
    r18 = CPyDict_CheckSize(d, r3)
    goto L1
L4:
    r19 = CPy_NoErrOccured()
L5:
    return 1
def typeddict(d):
    d :: dict
    r0 :: short_int
    r1 :: native_int
    r2 :: short_int
    r3 :: object
    r4 :: tuple[bool, short_int, object, object]
    r5 :: short_int
    r6 :: bool
    r7, r8 :: object
    r9, k :: str
    v :: object
    r10 :: str
    r11 :: i32
    r12 :: bit
    r13 :: object
    r14, r15, r16 :: bit
    name :: object
    r17, r18 :: bit
L0:
    r0 = 0
    r1 = PyDict_Size(d)
    r2 = r1 << 1
    r3 = CPyDict_GetItemsIter(d)
L1:
    r4 = CPyDict_NextItem(r3, r0)
    r5 = r4[1]
    r0 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L9 :: bool
L2:
    r7 = r4[2]
    r8 = r4[3]
    r9 = cast(str, r7)
    k = r9
    v = r8
    r10 = 'name'
    r11 = PyUnicode_Compare(k, r10)
    r12 = r11 == -1
    if r12 goto L3 else goto L5 :: bool
L3:
    r13 = PyErr_Occurred()
    r14 = r13 != 0
    if r14 goto L4 else goto L5 :: bool
L4:
    r15 = CPy_KeepPropagating()
L5:
    r16 = r11 == 0
    if r16 goto L6 else goto L7 :: bool
L6:
    name = v
L7:
L8:
    r17 = CPyDict_CheckSize(d, r2)
    goto L1
L9:
    r18 = CPy_NoErrOccured()
L10:
    return 1

[case testDictLoadAddress]
def f() -> None:
    x = dict
[out]
def f():
    r0, x :: object
L0:
    r0 = load_address PyDict_Type
    x = r0
    return 1

[case testDictClear]
from typing import Dict
def f(d: Dict[int, int]) -> None:
    return d.clear()
[out]
def f(d):
    d :: dict
    r0 :: bit
L0:
    r0 = CPyDict_Clear(d)
    return 1

[case testDictCopy]
from typing import Dict
def f(d: Dict[int, int]) -> Dict[int, int]:
    return d.copy()
[out]
def f(d):
    d, r0 :: dict
L0:
    r0 = CPyDict_Copy(d)
    return r0

[case testDictSetdefault]
from typing import Dict
def f(d: Dict[object, object]) -> object:
    return d.setdefault('a', 'b')

def f2(d: Dict[object, object], flag: bool) -> object:
    if flag:
        return d.setdefault('a', set())
    else:
        return d.setdefault('a', set('b'))

def f3(d: Dict[object, object], flag: bool) -> object:
    if flag:
        return d.setdefault('a', [])
    else:
        return d.setdefault('a', [1])

def f4(d: Dict[object, object], flag: bool) -> object:
    if flag:
        return d.setdefault('a', {})
    else:
        return d.setdefault('a', {'c': 1})
[out]
def f(d):
    d :: dict
    r0, r1 :: str
    r2 :: object
L0:
    r0 = 'a'
    r1 = 'b'
    r2 = CPyDict_SetDefault(d, r0, r1)
    return r2
def f2(d, flag):
    d :: dict
    flag :: bool
    r0 :: str
    r1 :: object
    r2, r3 :: str
    r4 :: set
    r5, r6 :: object
L0:
    if flag goto L1 else goto L2 :: bool
L1:
    r0 = 'a'
    r1 = CPyDict_SetDefaultWithEmptyDatatype(d, r0, 3)
    return r1
L2:
    r2 = 'a'
    r3 = 'b'
    r4 = PySet_New(r3)
    r5 = CPyDict_SetDefault(d, r2, r4)
    return r5
L3:
    r6 = box(None, 1)
    return r6
def f3(d, flag):
    d :: dict
    flag :: bool
    r0 :: str
    r1 :: object
    r2 :: str
    r3 :: list
    r4 :: object
    r5, r6 :: ptr
    r7, r8 :: object
L0:
    if flag goto L1 else goto L2 :: bool
L1:
    r0 = 'a'
    r1 = CPyDict_SetDefaultWithEmptyDatatype(d, r0, 1)
    return r1
L2:
    r2 = 'a'
    r3 = PyList_New(1)
    r4 = object 1
    r5 = get_element_ptr r3 ob_item :: PyListObject
    r6 = load_mem r5 :: ptr*
    set_mem r6, r4 :: builtins.object*
    keep_alive r3
    r7 = CPyDict_SetDefault(d, r2, r3)
    return r7
L3:
    r8 = box(None, 1)
    return r8
def f4(d, flag):
    d :: dict
    flag :: bool
    r0 :: str
    r1 :: object
    r2, r3 :: str
    r4 :: object
    r5 :: dict
    r6, r7 :: object
L0:
    if flag goto L1 else goto L2 :: bool
L1:
    r0 = 'a'
    r1 = CPyDict_SetDefaultWithEmptyDatatype(d, r0, 2)
    return r1
L2:
    r2 = 'a'
    r3 = 'c'
    r4 = object 1
    r5 = CPyDict_Build(1, r3, r4)
    r6 = CPyDict_SetDefault(d, r2, r5)
    return r6
L3:
    r7 = box(None, 1)
    return r7