LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_append
awlval* builtin_append(awlenv* e, awlval* a) {
    AWLASSERT_MINARGCOUNT(a, 2, "append");
    EVAL_ARGS(e, a);

    for (int i = 0; i < a->count; i++) {
        AWLASSERT_TYPE(a, i, AWLVAL_QEXPR, "append");
    }

    awlval* x = awlval_pop(a, 0);
    while (a->count) {
        x = awlval_join(x, awlval_pop(a, 0));
    }

    awlval_del(a);
    return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jle 0x3723
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x3749
movl 0x4(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
cmpq %r14, %rax
je 0x3752
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movl (%rcx), %edi
cmpl $0xc, %edi
jne 0x377c
incq %r14
jmp 0x370a
leaq 0xc99d(%rip), %rdi      # 0x100c7
leaq 0xca92(%rip), %rsi      # 0x101c3
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
cmpl $0x0, 0x4(%rbx)
je 0x373e
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %r14, %rdi
movq %rax, %rsi
callq 0xe33d
jmp 0x375c
callq 0xd97c
movq %rax, %r15
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xc9ae(%rip), %rdi      # 0x10141
leaq 0xca29(%rip), %rsi      # 0x101c3
movl %r14d, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x373b
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_cons
awlval* builtin_cons(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "cons");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 1, AWLVAL_QEXPR, "cons");

    awlval* v = awlval_pop(a, 0);
    awlval* x = awlval_take(a, 0);
    awlval_add_front(x, v);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x3804
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x37ff
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3832
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xdfd6
movq %rbx, %rax
jmp 0x382a
leaq 0xc8ef(%rip), %rdi      # 0x100fa
leaq 0xc9b8(%rip), %rsi      # 0x101ca
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd97c
movq %rax, %r14
pushq $0xc
popq %rdi
callq 0xd97c
leaq 0xc8f8(%rip), %rdi      # 0x10141
leaq 0xc97a(%rip), %rsi      # 0x101ca
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x381c
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dictget
awlval* builtin_dictget(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-get");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-get");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-get");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    awlval* v = awlval_get_dict(d, k);
    awlval_del(d);
    awlval_del(k);
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x388a
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x38a7
movq %rbx, %rax
jmp 0x395b
leaq 0xc869(%rip), %rdi      # 0x100fa
leaq 0xc937(%rip), %rsi      # 0x101cf
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x394d
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x38fd
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x391f
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe055
movq %rax, %r15
movq %r14, %rdi
callq 0xded1
movq %rbx, %rdi
callq 0xded1
movq %r15, %rax
jmp 0x395b
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc82d(%rip), %rdi      # 0x10141
leaq 0xc8b4(%rip), %rsi      # 0x101cf
xorl %edx, %edx
jmp 0x3940
callq 0xd97c
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0xd97c
leaq 0xc80b(%rip), %rdi      # 0x10141
leaq 0xc892(%rip), %rsi      # 0x101cf
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dictset
awlval* builtin_dictset(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "dict-set");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-set");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-set");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_pop(a, 0);
    awlval* v = awlval_take(a, 0);

    d = awlval_add_dict(d, k, v);
    awlval_del(k);
    awlval_del(v);
    return d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x3989
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x39a6
movq %rbx, %rax
jmp 0x3a5f
leaq 0xc76a(%rip), %rdi      # 0x100fa
leaq 0xc841(%rip), %rsi      # 0x101d8
pushq $0x3
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x3a51
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x3a01
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x3a23
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xe030
movq %rax, %r14
movq %r15, %rdi
callq 0xded1
jmp 0x3a54
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc729(%rip), %rdi      # 0x10141
leaq 0xc7b9(%rip), %rsi      # 0x101d8
xorl %edx, %edx
jmp 0x3a44
callq 0xd97c
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0xd97c
leaq 0xc707(%rip), %rdi      # 0x10141
leaq 0xc797(%rip), %rsi      # 0x101d8
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dictdel
awlval* builtin_dictdel(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-del");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-del");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-del");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    awlval_rm_dict(d, k);
    awlval_del(k);
    return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x3a8c
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3aa9
movq %rbx, %rax
jmp 0x3b52
leaq 0xc667(%rip), %rdi      # 0x100fa
leaq 0xc747(%rip), %rsi      # 0x101e1
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x3b44
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x3af4
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x3b16
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe062
movq %rbx, %rdi
callq 0xded1
movq %r14, %rbx
jmp 0x3a84
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc636(%rip), %rdi      # 0x10141
leaq 0xc6cf(%rip), %rsi      # 0x101e1
xorl %edx, %edx
jmp 0x3b37
callq 0xd97c
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0xd97c
leaq 0xc614(%rip), %rdi      # 0x10141
leaq 0xc6ad(%rip), %rsi      # 0x101e1
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dicthaskey
awlval* builtin_dicthaskey(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "dict-haskey?");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-haskey?");
    AWLASSERT_TYPE(a, 1, AWLVAL_QSYM, "dict-haskey?");

    awlval* d = awlval_pop(a, 0);
    awlval* k = awlval_take(a, 0);

    bool v = awlval_haskey_dict(d, k);
    awlval_del(d);
    awlval_del(k);
    return awlval_bool(v);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x3b81
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3b9e
movq %rbx, %rax
jmp 0x3c59
leaq 0xc572(%rip), %rdi      # 0x100fa
leaq 0xc65b(%rip), %rsi      # 0x101ea
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x3c4b
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x3bfb
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x3c1d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe087
movl %eax, %ebp
movq %r14, %rdi
callq 0xded1
movq %rbx, %rdi
callq 0xded1
movzbl %bpl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xdd3e
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc52f(%rip), %rdi      # 0x10141
leaq 0xc5d1(%rip), %rsi      # 0x101ea
xorl %edx, %edx
jmp 0x3c3e
callq 0xd97c
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0xd97c
leaq 0xc50d(%rip), %rdi      # 0x10141
leaq 0xc5af(%rip), %rsi      # 0x101ea
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dictkeys
awlval* builtin_dictkeys(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "dict-keys");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-keys");

    awlval* d = awlval_take(a, 0);

    awlval* v = awlval_keys_dict(d);
    awlval_del(d);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3c82
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3cb0
movq %rbx, %rax
jmp 0x3ca8
leaq 0xc471(%rip), %rdi      # 0x100fa
leaq 0xc567(%rip), %rsi      # 0x101f7
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xa, %edi
jne 0x3cd5
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %rax, %rdi
callq 0xe09d
jmp 0x3c9a
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc455(%rip), %rdi      # 0x10141
leaq 0xc504(%rip), %rsi      # 0x101f7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3c9a
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_dictvals
awlval* builtin_dictvals(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "dict-vals");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_DICT, "dict-vals");

    awlval* d = awlval_take(a, 0);

    awlval* v = awlval_vals_dict(d);
    awlval_del(d);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3d28
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3d56
movq %rbx, %rax
jmp 0x3d4e
leaq 0xc3cb(%rip), %rdi      # 0x100fa
leaq 0xc4cb(%rip), %rsi      # 0x10201
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xa, %edi
jne 0x3d7b
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movq %rax, %rdi
callq 0xe105
jmp 0x3d40
callq 0xd97c
movq %rax, %r14
pushq $0xa
popq %rdi
callq 0xd97c
leaq 0xc3af(%rip), %rdi      # 0x10141
leaq 0xc468(%rip), %rsi      # 0x10201
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x3d40
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_len
awlval* builtin_len(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "len");
    EVAL_ARGS(e, a);
    AWLASSERT_ISCOLLECTION(a, 0, "len");

    awlval* x = awlval_int(a->cell[0]->length);
    awlval_del(a);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3dec
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x3e12
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
ja 0x3e1d
movl $0x1430, %ecx           # imm = 0x1430
btl %edi, %ecx
jae 0x3e1d
movslq 0x10(%rax), %rdi
callq 0xdc64
jmp 0x3e04
leaq 0xc307(%rip), %rdi      # 0x100fa
leaq 0xc411(%rip), %rsi      # 0x1020b
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd97c
leaq 0xc3e6(%rip), %rdi      # 0x1020f
leaq 0xc3db(%rip), %rsi      # 0x1020b
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb45
jmp 0x3e04
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_reverse
awlval* builtin_reverse(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "reverse");
    EVAL_ARGS(e, a);
    AWLASSERT_ISORDEREDCOLLECTION(a, 0, "reverse");

    awlval* collection = awlval_take(a, 0);

    return awlval_reverse(collection);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3e62
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3e90
movq %rbx, %rax
jmp 0x3e88
leaq 0xc291(%rip), %rdi      # 0x100fa
leaq 0xc3f0(%rip), %rsi      # 0x10260
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
ja 0x3ec1
movl $0x1030, %eax           # imm = 0x1030
btl %edi, %eax
jae 0x3ec1
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe41c
callq 0xd97c
leaq 0xc39b(%rip), %rdi      # 0x10268
leaq 0xc38c(%rip), %rsi      # 0x10260
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb45
jmp 0x3e7a
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_if
awlval* builtin_if(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "if");

    EVAL_SINGLE_ARG(e, a, 0);
    AWLASSERT_TYPE(a, 0, AWLVAL_BOOL, "if");

    awlval* x;
    /* does not eval result; sends it back to awlval_eval for
     * potential tail call optimization */
    if (a->cell[0]->bln) {
        x = awlval_pop(a, 1);
    } else {
        x = awlval_pop(a, 2);
    }

    awlval_del(a);
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x4164
movq %rbx, %rsi
xorl %edx, %edx
callq 0x55b2
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x418a
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x6, %edi
jne 0x4195
movzbl 0x18(%rax), %eax
pushq $0x2
popq %rsi
subl %eax, %esi
movq %rbx, %rdi
callq 0xe2bf
jmp 0x417c
leaq 0xbf8f(%rip), %rdi      # 0x100fa
leaq 0xc1b7(%rip), %rsi      # 0x10329
pushq $0x3
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd97c
movq %rax, %r14
pushq $0x6
popq %rdi
callq 0xd97c
leaq 0xbf95(%rip), %rdi      # 0x10141
leaq 0xc176(%rip), %rsi      # 0x10329
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x417c
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_lambda
awlval* builtin_lambda(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "fn");
    AWLASSERT_ISEXPR(a, 0, "fn");

    for (int i = 0; i < a->cell[0]->count; i++) {
        AWLASSERT(a, (a->cell[0]->cell[i]->type == AWLVAL_SYM),
                "function 'fn' cannot take non-symbol argument at position %i", i);
    }

    awlval* formals = awlval_pop(a, 0);
    awlval* body = awlval_take(a, 0);
    return awlval_lambda(e, formals, body);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x4631
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
leal -0xb(%rdi), %ecx
cmpl $0x1, %ecx
ja 0x464b
movl 0x4(%rax), %ecx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x466c
movq 0x8(%rax), %rdx
movq (%rdx,%rsi,8), %rdx
cmpl $0x3, (%rdx)
jne 0x4696
incq %rsi
jmp 0x461a
leaq 0xbac2(%rip), %rdi      # 0x100fa
leaq 0xbe21(%rip), %rsi      # 0x10460
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x46a4
callq 0xd97c
leaq 0xbe0c(%rip), %rdi      # 0x10463
leaq 0xbe02(%rip), %rsi      # 0x10460
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb45
jmp 0x46a4
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xdd9d
leaq 0xbe17(%rip), %rdi      # 0x104b4
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_macro
awlval* builtin_macro(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 3, "macro");
    AWLASSERT_TYPE(a, 0, AWLVAL_SYM, "macro");
    AWLASSERT_ISEXPR(a, 1, "macro");

    int index = awlenv_index(e, a->cell[0]);
    AWLASSERT(a, index == -1,
            "cannot redefine '%s'", a->cell[0]->sym);

    for (int i = 0; i < a->cell[1]->count; i++) {
        AWLASSERT(a, (a->cell[1]->cell[i]->type == AWLVAL_SYM),
                "macro cannot take non-symbol argument at position %i", i);
    }

    awlval* name = awlval_pop(a, 0);
    awlval* formals = awlval_pop(a, 0);
    awlval* body = awlval_take(a, 0);

    awlval* macro = awlval_macro(e, formals, body);

    awlenv_put(e, name, macro);

    awlval_del(name);
    awlval_del(macro);
    return awlval_qexpr();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x3, %ecx
jne 0x4716
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movl (%rsi), %edi
cmpl $0x3, %edi
jne 0x4730
movq 0x8(%rax), %rax
movl (%rax), %edi
leal -0xb(%rdi), %eax
cmpl $0x2, %eax
jae 0x475f
movq %r14, %rdi
callq 0xee5d
movq 0x8(%rbx), %rcx
cmpl $-0x1, %eax
je 0x4799
movq (%rcx), %rax
movq 0x18(%rax), %rsi
leaq 0xbc2d(%rip), %rdi      # 0x1033a
xorl %eax, %eax
callq 0xdb45
jmp 0x477f
leaq 0xb9dd(%rip), %rdi      # 0x100fa
leaq 0xbdcd(%rip), %rsi      # 0x104f1
pushq $0x3
popq %rdx
xorl %eax, %eax
callq 0xdb45
jmp 0x477f
callq 0xd97c
movq %rax, %r14
pushq $0x3
popq %rdi
callq 0xd97c
leaq 0xb9fa(%rip), %rdi      # 0x10141
leaq 0xbda3(%rip), %rsi      # 0x104f1
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x477f
callq 0xd97c
leaq 0xbcf8(%rip), %rdi      # 0x10463
leaq 0xbd7f(%rip), %rsi      # 0x104f1
pushq $0x1
popq %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rcx), %rax
movl 0x4(%rax), %ecx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x47be
movq 0x8(%rax), %rdx
movq (%rdx,%rsi,8), %rdx
cmpl $0x3, (%rdx)
jne 0x4821
incq %rsi
jmp 0x47a7
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xde26
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xeeb8
movq %r15, %rdi
callq 0xded1
movq %rbx, %rdi
callq 0xded1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xde89
leaq 0xbccf(%rip), %rdi      # 0x104f7
xorl %eax, %eax
callq 0xdb45
jmp 0x477f
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_typeof
awlval* builtin_typeof(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "typeof");
    EVAL_ARGS(e, a);

    awlval* arg = awlval_take(a, 0);
    awlval* res = awlval_qsym(awlval_type_sysname(arg->type));
    awlval_del(arg);
    return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x4871
movq %rbx, %rsi
callq 0x55f9
movq %rax, %r14
cmpl $0x2, (%rax)
je 0x4894
movq %r14, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %rbx
movl (%rax), %edi
callq 0xd99a
movq %rax, %rdi
callq 0xdce8
jmp 0x4889
leaq 0xb882(%rip), %rdi      # 0x100fa
leaq 0xbcad(%rip), %rsi      # 0x1052c
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_convert
awlval* builtin_convert(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 2, "convert");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QSYM, "convert");

    awlval* tsym = awlval_pop(a, 0);
    awlval* v = awlval_take(a, 0);

    awlval* res;
    awlval_type_t type = awlval_parse_sysname(tsym->sym);
    if (errno != EINVAL) {
        res = awlval_convert(type, v);
    } else {
        res = awlval_err("no such type: %s", tsym->sym);
    }

    awlval_del(tsym);
    awlval_del(v);

    return res;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x2, %ecx
jne 0x4914
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x4988
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x493c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rax, %r15
movq 0x18(%r14), %rdi
callq 0xd9b8
movl %eax, %ebx
callq 0x2060
cmpl $0x16, (%rax)
jne 0x496b
movq 0x18(%r14), %rsi
leaq 0xbc30(%rip), %rdi      # 0x1053b
xorl %eax, %eax
callq 0xdb45
jmp 0x4975
leaq 0xb7df(%rip), %rdi      # 0x100fa
leaq 0xbc11(%rip), %rsi      # 0x10533
pushq $0x2
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rax
jmp 0x498b
callq 0xd97c
movq %rax, %r14
pushq $0x4
popq %rdi
callq 0xd97c
leaq 0xb7ee(%rip), %rdi      # 0x10141
leaq 0xbbd9(%rip), %rsi      # 0x10533
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x492c
movl %ebx, %edi
movq %r15, %rsi
callq 0xe63a
movq %rax, %rbx
movq %r14, %rdi
callq 0xded1
movq %r15, %rdi
callq 0xded1
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/util.h
// Function: safe_malloc
static inline void* safe_malloc(size_t size) {
    char* p = malloc(size);
    if (p == NULL) {
        fprintf(stderr, "failed to allocate memory\n");
        exit(-1);
    }
    return p;
}

// Assembly:
pushq %rax
callq 0x2290
testq %rax, %rax
je 0x4c13
popq %rcx
retq
movq 0x143d6(%rip), %rax     # 0x18ff0
movq (%rax), %rcx
leaq 0xb99d(%rip), %rdi      # 0x105c1
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x2390
pushq $-0x1
popq %rdi
callq 0x2380
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_print
awlval* builtin_print(awlenv* e, awlval* a) {
    EVAL_ARGS(e, a);
    for (int i = 0; i < a->count; i++) {
        if (i != 0) {
            awl_printf(" ");
        }
        if (a->cell[i]->type == AWLVAL_STR) {
            awl_printf("%s", a->cell[i]->str);
        } else {
            awlval_print(a->cell[i]);
        }
    }
    awlval_del(a);
    return awlval_qexpr();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4c5b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb8e7(%rip), %r14      # 0x10549
leaq 0xc8e1(%rip), %r15      # 0x1154a
xorl %r12d, %r12d
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jge 0x4cab
testq %r12, %r12
je 0x4c84
movq %r15, %rdi
xorl %eax, %eax
callq 0xd37a
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpl $0x5, (%rdi)
jne 0x4ca1
movq 0x18(%rdi), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xd37a
jmp 0x4ca6
callq 0xd47d
incq %r12
jmp 0x4c6c
movq %rbx, %rdi
callq 0xded1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xde89
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/builtins.c
// Function: builtin_error
awlval* builtin_error(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "error");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_STR, "error");

    awlval* err = awlval_err(a->cell[0]->str);
    awlval_del(a);
    return err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x4d71
movq %rbx, %rsi
callq 0x55f9
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x4d97
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x5, %edi
jne 0x4da2
movq 0x18(%rax), %rdi
xorl %eax, %eax
callq 0xdb45
jmp 0x4d89
leaq 0xb382(%rip), %rdi      # 0x100fa
leaq 0xb821(%rip), %rsi      # 0x105a0
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r14
movq %rbx, %rdi
callq 0xded1
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xd97c
movq %rax, %r14
pushq $0x5
popq %rdi
callq 0xd97c
leaq 0xb388(%rip), %rdi      # 0x10141
leaq 0xb7e0(%rip), %rsi      # 0x105a0
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xdb45
jmp 0x4d89
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_new
dict* dict_new(const copy_fn copier, const del_fn deleter) {
    dict* d = dict_new_no_bindings();
    d->copier = copier;
    d->deleter = deleter;
    return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4e07
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_new_no_bindings
dict* dict_new_no_bindings(void) {
    dict* d = safe_malloc(sizeof(dict));
    d->size = DICT_INITIAL_SIZE;
    d->count = 0;
    d->syms = safe_malloc(sizeof(char*) * DICT_INITIAL_SIZE);
    for (int i = 0; i < DICT_INITIAL_SIZE; i++) {
        d->syms[i] = NULL;
    }
    d->vals = safe_malloc(sizeof(void*) * DICT_INITIAL_SIZE);
    d->copier = NULL;
    d->deleter = NULL;
    return d;
}

// Assembly:
pushq %rbx
pushq $0x28
popq %rdi
callq 0x4e54
movq %rax, %rbx
movq $0x10, (%rax)
movl $0x80, %edi
callq 0x4e54
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x10, %rcx
je 0x4e3a
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x4e2a
movl $0x80, %edi
callq 0x4e54
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_del
void dict_del(dict* d) {
    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            free(d->syms[i]);
            maybe_delete(d, d->vals[i]);
        }
    }
    free(d->syms);
    free(d->vals);
    free(d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0x4ec1
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x4ebc
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x4ebc
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
incq %r14
jmp 0x4e8f
callq 0x23f0
movq 0x10(%rbx), %rdi
callq 0x23f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x23f0
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_findslot
static int dict_findslot(const dict* d, const char* k) {
    unsigned int i = dict_hash(k) % d->size;
    unsigned int probe = 1;
    while (d->syms[i] && !streq(d->syms[i], k)) {
        i = (i + probe) % d->size;
        probe += DICT_PROBE_INTERVAL;
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1505, %eax           # imm = 0x1505
movq %rsi, %rcx
movsbl (%rcx), %edx
testl %edx, %edx
je 0x4f20
imull $0x21, %eax, %eax
xorl %edx, %eax
incq %rcx
jmp 0x4f0f
xorl %edx, %edx
divl (%r14)
movl %edx, %ebp
pushq $0x1
popq %r15
movq 0x8(%r14), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x4f57
movq %rbx, %rsi
callq 0xf0d6
testb %al, %al
jne 0x4f57
addl %r15d, %ebp
movl %ebp, %eax
xorl %edx, %edx
divl (%r14)
incl %r15d
movl %edx, %ebp
jmp 0x4f2b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_set
static void dict_set(dict* d, const char* k, void* v) {
    int i = dict_findslot(d, k);
    if (d->syms[i]) {
        v = maybe_copy(d, v);
        maybe_delete(d, d->vals[i]);
        d->vals[i] = v;
        return;
    }

    /* no existing entry found */
    d->count++;
    /* resize if needed */
    if (d->count / (float)d->size >= DICT_LOAD_FACTOR) {
        dict_resize(d);
        i = dict_findslot(d, k);
    }
    d->syms[i] = safe_malloc(strlen(k) + 1);
    strcpy(d->syms[i], k);
    d->vals[i] = maybe_copy(d, v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4efa
movq 0x8(%rbx), %r12
movslq %eax, %r13
cmpq $0x0, (%r12,%r13,8)
je 0x500a
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4feb
movq %r14, %rdi
callq *%rax
movq %rax, %r14
movq 0x20(%rbx), %rax
addq $0x10, %rbx
testq %rax, %rax
je 0x5120
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rdi
callq *%rax
jmp 0x5120
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cvtsi2ss %eax, %xmm0
movslq (%rbx), %rbp
cvtsi2ss %ebp, %xmm1
divss %xmm1, %xmm0
ucomiss 0xb5b4(%rip), %xmm0     # 0x105dc
jb 0x50e2
leal (,%rbp,2), %eax
movl %eax, (%rbx)
movq 0x10(%rbx), %r13
movq %rbp, %rdi
shlq $0x4, %rdi
callq 0x4e54
movq %rax, 0x8(%rbx)
movslq (%rbx), %rdi
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %ecx
cmovgl %edi, %ecx
cmpq %rax, %rcx
je 0x506d
movq 0x8(%rbx), %rdx
andq $0x0, (%rdx,%rax,8)
incq %rax
jmp 0x505a
movq %r14, (%rsp)
shlq $0x3, %rdi
callq 0x4e54
movq %rax, 0x10(%rbx)
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
cmpq %r14, %rbp
je 0x50c0
movq (%r12,%r14,8), %rsi
testq %rsi, %rsi
je 0x50bb
movq (%r13,%r14,8), %rdx
movq %rbx, %rdi
callq 0x4fb3
movq (%r12,%r14,8), %rdi
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x50bb
movq (%r13,%r14,8), %rdi
callq *%rax
incq %r14
jmp 0x5087
movq %r12, %rdi
callq 0x23f0
movq %r13, %rdi
callq 0x23f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4efa
movslq %eax, %r13
movq (%rsp), %r14
movq %r15, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x4e54
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
movq %r15, %rsi
callq 0x2080
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x511c
movq %r14, %rdi
callq *%rax
movq %rax, %r14
addq $0x10, %rbx
movq (%rbx), %rax
movq %r14, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_rm
void dict_rm(dict* d, const char* k) {
    int i = dict_findslot(d, k);
    if (d->syms[i]) {
        d->count--;
        maybe_delete(d, d->vals[i]);
        free(d->syms[i]);
        d->syms[i] = NULL;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4efa
movq 0x8(%rbx), %rcx
movslq %eax, %r14
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x517e
decl 0x4(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5170
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x23f0
movq 0x8(%rbx), %rax
andq $0x0, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_copy
dict* dict_copy(const dict* d) {
    dict* n = safe_malloc(sizeof(dict));
    n->size = d->size;
    n->count = 0;
    n->copier = d->copier;
    n->deleter = d->deleter;
    n->syms = safe_malloc(sizeof(char*) * d->size);
    for (int i = 0; i < d->size; i++) {
        n->syms[i] = NULL;
    }
    n->vals = safe_malloc(sizeof(void*) * d->size);

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            dict_set(n, d->syms[i], d->vals[i]);
        }
    }

    return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x4e54
movq %rax, %r14
movslq (%rbx), %rdi
movl %edi, (%rax)
andl $0x0, 0x4(%rax)
movups 0x18(%rbx), %xmm0
movups %xmm0, 0x18(%rax)
shlq $0x3, %rdi
callq 0x4e54
movq %rax, 0x8(%r14)
movslq (%rbx), %rdi
xorl %ecx, %ecx
testl %edi, %edi
movl $0x0, %edx
cmovgl %edi, %edx
cmpq %rcx, %rdx
je 0x51d5
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x51c6
shlq $0x3, %rdi
callq 0x4e54
movq %rax, 0x10(%r14)
xorl %r15d, %r15d
movslq (%rbx), %rax
cmpq %rax, %r15
jge 0x520f
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x520a
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
callq 0x4fb3
incq %r15
jmp 0x51e5
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_all_keys
char** dict_all_keys(const dict* d) {
    char** keys = safe_malloc(sizeof(char*) * d->count);
    int offset = 0;

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            keys[offset++] = d->syms[i];
        }
    }
    return keys;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdi
shlq $0x3, %rdi
callq 0x4e54
movslq (%rbx), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %rdx
jge 0x5254
movq 0x8(%rbx), %rdi
movq (%rdi,%rdx,8), %rdi
testq %rdi, %rdi
je 0x524f
movslq %esi, %r8
incl %esi
movq %rdi, (%rax,%r8,8)
incq %rdx
jmp 0x5234
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/dict.c
// Function: dict_all_vals
void** dict_all_vals(const dict* d) {
    void** vals = safe_malloc(sizeof(void*) * d->count);
    int offset = 0;

    for (int i = 0; i < d->size; i++) {
        if (d->syms[i]) {
            vals[offset++] = d->vals[i];
        }
    }
    return vals;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x4(%rdi), %rdi
shlq $0x3, %rdi
callq 0x4e54
movslq (%rbx), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rcx, %rdx
jge 0x5294
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi,%rdx,8)
je 0x528f
movq 0x10(%rbx), %rdi
movq (%rdi,%rdx,8), %rdi
movslq %esi, %r8
incl %esi
movq %rdi, (%rax,%r8,8)
incq %rdx
jmp 0x526e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/eval.c
// Function: awlval_eval_sexpr
awlval* awlval_eval_sexpr(awlenv* e, awlval* v) {
    if (v->count == 0) {
        awlval_del(v);
        return awlval_err("cannot evaluate empty %s", awlval_type_name(AWLVAL_SEXPR));
    }

    EVAL_SINGLE_ARG(e, v, 0);
    awlval* f = awlval_pop(v, 0);

    if (!ISCALLABLE(f->type)) {
        awlval* err = awlval_err("cannot evaluate %s; incorrect type for arg 0; got %s, expected callable",
                awlval_type_name(AWLVAL_SEXPR), awlval_type_name(f->type));
        awlval_del(v);
        awlval_del(f);
        return err;
    }

    awlval* result = awlval_call(e, f, v);
    awlval_del(f);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x4(%rsi)
je 0x544e
movq %rdi, %r15
xorl %edx, %edx
callq 0x55b2
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x5449
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe2bf
movq %rax, %r14
movl (%rax), %eax
addl $-0x7, %eax
cmpl $0x3, %eax
jae 0x5474
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5661
movq %rax, %rbx
movq %r14, %rdi
callq 0xded1
movq %rbx, %rax
jmp 0x54b1
movq %rsi, %rdi
callq 0xded1
pushq $0xb
popq %rdi
callq 0xd97c
leaq 0xb1f1(%rip), %rdi      # 0x10656
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xdb45
pushq $0xb
popq %rdi
callq 0xd97c
movq %rax, %r15
movl (%r14), %edi
callq 0xd97c
leaq 0xb1e1(%rip), %rdi      # 0x1066f
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xdb45
movq %rax, %r15
movq %rbx, %rdi
callq 0xded1
movq %r14, %rdi
callq 0xded1
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/eval.c
// Function: awlval_eval_inside_qexpr
awlval* awlval_eval_inside_qexpr(awlenv* e, awlval* v) {
    switch (v->type) {
        case AWLVAL_SEXPR:
        case AWLVAL_QEXPR:
        {
            for (int i = 0; i < v->count; i++) {
                // Special case for C-Expressions
                if (v->cell[i]->type == AWLVAL_CEXPR) {
                    awlval* cexpr = awlval_eval_cexpr(e, awlval_pop(v, i));
                    if (cexpr->type == AWLVAL_ERR) {
                        awlval_del(v);
                        return cexpr;
                    }

                    // Populate current container with result of CExpr
                    if (cexpr->type == AWLVAL_QEXPR) {
                        v = awlval_shift(v, cexpr, i);
                    } else {
                        v = awlval_insert(v, cexpr, i);
                    }
                } else {
                    v->cell[i] = awlval_eval_inside_qexpr(e, v->cell[i]);
                    if (v->cell[i]->type == AWLVAL_ERR) {
                        return awlval_take(v, i);
                    }
                }
            }
            return v;
            break;
        }

        case AWLVAL_EEXPR:
        {
            return awlval_eval(e, awlval_take(v, 0));
            break;

        }

        default:
            return v;
            break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
leal -0xb(%rax), %ecx
cmpl $0x2, %ecx
jae 0x555e
xorl %r15d, %r15d
movslq 0x4(%r14), %rax
cmpq %rax, %r15
jge 0x5583
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
cmpl $0xe, (%rsi)
jne 0x5529
movq %r14, %rdi
movl %r15d, %esi
callq 0xe2bf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x594d
movq %rax, %r12
movl (%rax), %eax
movq %r14, %rdi
cmpl $0xc, %eax
je 0x5548
cmpl $0x2, %eax
je 0x55ab
movq %r12, %rsi
movl %r15d, %edx
callq 0xe378
jmp 0x5553
movq %rbx, %rdi
callq 0x54b7
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x5556
jmp 0x5595
movq %r12, %rsi
movl %r15d, %edx
callq 0xe3df
movq %rax, %r14
incq %r15
jmp 0x54d6
cmpl $0xd, %eax
jne 0x5583
movq %r14, %rdi
xorl %esi, %esi
callq 0xe31b
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x52a8
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe31b
callq 0xded1
jmp 0x5586
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/eval.c
// Function: awlval_eval_arg
awlval* awlval_eval_arg(awlenv* e, awlval* v, int arg) {
    v->cell[arg] = awlval_eval(e, v->cell[arg]);
    if (v->cell[arg]->type == AWLVAL_ERR) {
        return awlval_take(v, arg);
    }
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movslq %edx, %r15
movq (%rax,%r15,8), %rsi
callq 0x52a8
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x55f0
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0xe31b
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/eval.c
// Function: awlval_eval_args
awlval* awlval_eval_args(awlenv* e, awlval* v) {
    for (int i = 0; i < v->count; i++) {
        v->cell[i] = awlval_eval(e, v->cell[i]);
    }

    for (int i = 0; i < v->count; i++) {
        if (v->cell[i]->type == AWLVAL_ERR) {
            return awlval_take(v, i);
        }
    }
    return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x562d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x52a8
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x5607
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
cmpq %rsi, %rax
je 0x564b
movq 0x8(%rbx), %rcx
movq (%rcx,%rsi,8), %rcx
cmpl $0x2, (%rcx)
je 0x5654
incq %rsi
jmp 0x5634
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe31b
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/eval.c
// Function: awlval_eval_macro
awlval* awlval_eval_macro(awlval* m) {
    awlenv* e = awlenv_copy(m->env);
    awlval* b = awlval_copy(m->body);

    awlval* v = awlval_eval(e, b);

    awlenv_del(e);

    if (v->type == AWLVAL_QEXPR) {
        v->type = AWLVAL_SEXPR;
    }
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xe5f3
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0xe16d
movq %r14, %rdi
movq %rax, %rsi
callq 0x52a8
movq %rax, %rbx
movq %r14, %rdi
callq 0xdf56
cmpl $0xc, (%rbx)
jne 0x5942
movl $0xb, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/linenoise.c
// Function: strclone
static char *strclone(const char *str) {
    size_t size = strlen(str) + 1;
    char *copy = malloc(size);
    if (copy == NULL) return NULL;

    memcpy(copy, str, size);
    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x2290
testq %rax, %rax
je 0x5fc5
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2270
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/main.c
// Function: main
int main(int argc, char** argv) {
    setup_awl();
    awlenv* e = awlenv_new_top_level();

    /* if the only argument is the interpreter name, run repl */
    if (argc == 1) {
        run_repl(e);
    } else {
        run_scripts(e, argc, argv);
    }

    awlenv_del_top_level(e);
    teardown_awl();
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x2555
callq 0xe985
movq %rax, %rbx
movq %rax, %rdi
cmpl $0x1, %ebp
jne 0x6dcd
callq 0xd8be
jmp 0x6dd7
movl %ebp, %esi
movq %r14, %rdx
callq 0x24ec
movq %rbx, %rdi
callq 0xee4d
callq 0x256f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/mpc.c
// Function: mpc_stack_pushp
static void mpc_stack_pushp(mpc_stack_t *s, mpc_parser_t *p) {
  s->parsers_num++;
  mpc_stack_parsers_reserve_more(s);
  s->parsers[s->parsers_num-1] = p;
  s->states[s->parsers_num-1] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rdx), %ecx
movl %ecx, (%rdi)
cmpl %eax, %edx
jl 0x7dc7
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x8d18(%rip), %xmm0     # 0x10aa8
callq 0x23a0
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movslq 0x4(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x10(%rbx)
movl (%rbx), %ecx
movq 0x8(%rbx), %rax
movslq %ecx, %rcx
movq %r14, -0x8(%rax,%rcx,8)
movq 0x10(%rbx), %rax
andl $0x0, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/mpc.c
// Function: mpc_stack_popp
static void mpc_stack_popp(mpc_stack_t *s, mpc_parser_t **p, int *st) {
  *p = s->parsers[s->parsers_num-1];
  *st = s->states[s->parsers_num-1];
  s->parsers_num--;
  mpc_stack_parsers_reserve_less(s);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
movq -0x8(%rax,%rcx,8), %rax
movq %rax, (%rsi)
movq 0x10(%rdi), %rax
movl -0x4(%rax,%rcx,4), %eax
movl %eax, (%rdx)
movl (%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rdi)
cvtsi2sdl 0x4(%rdi), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %eax, %xmm0
movsd 0x8c85(%rip), %xmm1     # 0x10aa8
callq 0x20f0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x7e7a
movl 0x4(%rbx), %eax
decl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x8c6b(%rip), %xmm0     # 0x10ab0
callq 0x2340
cvttsd2si %xmm0, %eax
movl %eax, 0x4(%rbx)
movq 0x8(%rbx), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movslq 0x4(%rbx), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/mpc.c
// Function: mpc_stack_pushr
static void mpc_stack_pushr(mpc_stack_t *s, mpc_result_t x, int r) {
  s->results_num++;
  mpc_stack_results_reserve_more(s);
  s->results[s->results_num-1] = x;
  s->returns[s->results_num-1] = r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x18(%rdi), %edx
movl 0x1c(%rdi), %eax
leal 0x1(%rdx), %ecx
movl %ecx, 0x18(%rdi)
cmpl %eax, %edx
jl 0x7ee5
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x8bfd(%rip), %xmm0     # 0x10aa8
callq 0x23a0
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%r14)
movq 0x20(%r14), %rdi
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x22e0
movq %rax, 0x20(%r14)
movq 0x28(%r14), %rdi
movslq 0x1c(%r14), %rsi
shlq $0x2, %rsi
callq 0x22e0
movq %rax, 0x28(%r14)
movl 0x18(%r14), %ecx
movq 0x20(%r14), %rax
movslq %ecx, %rcx
movq %r15, -0x8(%rax,%rcx,8)
movq 0x28(%r14), %rax
movslq 0x18(%r14), %rcx
movl %ebx, -0x4(%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/mpc.c
// Function: mpc_err_fail
static mpc_err_t *mpc_err_fail(const char *filename, mpc_state_t s, const char *failure) {
  mpc_err_t *x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = s;
  x->expected_num = 0;
  x->expected = NULL;
  x->failure = malloc(strlen(failure) + 1);
  strcpy(x->failure, failure);
  x->recieved = ' ';
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
pushq $0x30
popq %rdi
callq 0x2290
movq %rax, %r14
movq %r12, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2080
movq %r15, (%r14)
movl %ebp, 0x8(%r14)
andl $0x0, 0xc(%r14)
andq $0x0, 0x20(%r14)
movq %rbx, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x18(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2080
movb $0x20, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/voithos[P]awl/src/mpc.c
// Function: mpc_err_new
static mpc_err_t *mpc_err_new(const char *filename, mpc_state_t s, const char *expected, char recieved) {
  mpc_err_t *x = malloc(sizeof(mpc_err_t));
  x->filename = malloc(strlen(filename) + 1);
  strcpy(x->filename, filename);
  x->state = s;
  x->expected_num = 1;
  x->expected = malloc(sizeof(char*));
  x->expected[0] = malloc(strlen(expected) + 1);
  strcpy(x->expected[0], expected);
  x->failure = NULL;
  x->recieved = recieved;
  return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r13
pushq $0x30
popq %rdi
callq 0x2290
movq %rax, %r15
movq %r13, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, 0x10(%r15)
movq %rax, %rdi
movq %r13, %rsi
callq 0x2080
movq %r12, (%r15)
movl %ebp, 0x8(%r15)
movl $0x1, 0xc(%r15)
pushq $0x8
popq %rdi
callq 0x2290
movq %rax, %r12
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2080
andq $0x0, 0x18(%r15)
movb %bl, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq