LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/voithos[P]awl/src/builtins.c
// Function: builtin_eval
awlval* builtin_eval(awlenv* e, awlval* a) {
    AWLASSERT_ARGCOUNT(a, 1, "eval");
    EVAL_ARGS(e, a);
    AWLASSERT_TYPE(a, 0, AWLVAL_QEXPR, "eval");

    awlval* x = awlval_take(a, 0);
    x->type = AWLVAL_SEXPR;
    return awlval_eval(e, x);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rsi), %ecx
cmpl $0x1, %ecx
jne 0x3e3d
movq %rdi, %r14
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x3e6d
movq %rbx, %rax
jmp 0x3e65
leaq 0xe2b6(%rip), %rdi      # 0x120fa
leaq 0xe373(%rip), %rsi      # 0x121be
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x3e9d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movl $0xb, (%rax)
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5be8
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe28b(%rip), %rdi      # 0x12141
leaq 0xe301(%rip), %rsi      # 0x121be
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3e57
// File: /workspace/github_c_makefile_star2_O3/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 0x3f3b
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x3f63
movslq 0x4(%rbx), %rax
testq %rax, %rax
jle 0x3f11
movq 0x8(%rbx), %rcx
xorl %r14d, %r14d
movq (%rcx,%r14,8), %rdx
movl (%rdx), %edi
cmpl $0xc, %edi
jne 0x3f6c
incq %r14
cmpq %r14, %rax
jne 0x3efe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
cmpl $0x0, 0x4(%rbx)
je 0x3f58
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %r14, %rdi
movq %rax, %rsi
callq 0x107d9
jmp 0x3f1b
leaq 0xe185(%rip), %rdi      # 0x120c7
leaq 0xe27a(%rip), %rsi      # 0x121c3
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xfc74
movq %rax, %r15
movl $0xc, %edi
callq 0xfc74
leaq 0xe1bc(%rip), %rdi      # 0x12141
leaq 0xe237(%rip), %rsi      # 0x121c3
movl %r14d, %edx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x3f55
// File: /workspace/github_c_makefile_star2_O3/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 0x3ff6
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x3ff1
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
jne 0x4026
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x103ae
movq %rbx, %rax
jmp 0x401e
leaq 0xe0fd(%rip), %rdi      # 0x120fa
leaq 0xe1c6(%rip), %rsi      # 0x121ca
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xfc74
movq %rax, %r14
movl $0xc, %edi
callq 0xfc74
leaq 0xe102(%rip), %rdi      # 0x12141
leaq 0xe184(%rip), %rsi      # 0x121ca
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x4010
// File: /workspace/github_c_makefile_star2_O3/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 0x4082
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x40a1
movq %rbx, %rax
jmp 0x415b
leaq 0xe071(%rip), %rdi      # 0x120fa
leaq 0xe13f(%rip), %rsi      # 0x121cf
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x414d
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x40f7
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x411b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1042d
movq %rax, %r15
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rdi
callq 0x1029f
movq %r15, %rax
jmp 0x415b
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xe031(%rip), %rdi      # 0x12141
leaq 0xe0b8(%rip), %rsi      # 0x121cf
xorl %edx, %edx
jmp 0x4140
callq 0xfc74
movq %rax, %r14
movl $0x4, %edi
callq 0xfc74
leaq 0xe00d(%rip), %rdi      # 0x12141
leaq 0xe094(%rip), %rsi      # 0x121cf
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4189
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x41a8
movq %rbx, %rax
jmp 0x4267
leaq 0xdf6a(%rip), %rdi      # 0x120fa
leaq 0xe041(%rip), %rsi      # 0x121d8
movl $0x3, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4259
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x4203
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x4227
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x10408
movq %rax, %r14
movq %r15, %rdi
callq 0x1029f
jmp 0x425c
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xdf25(%rip), %rdi      # 0x12141
leaq 0xdfb5(%rip), %rsi      # 0x121d8
xorl %edx, %edx
jmp 0x424c
callq 0xfc74
movq %rax, %r14
movl $0x4, %edi
callq 0xfc74
leaq 0xdf01(%rip), %rdi      # 0x12141
leaq 0xdf91(%rip), %rsi      # 0x121d8
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4294
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x42b3
movq %rbx, %rax
jmp 0x4362
leaq 0xde5f(%rip), %rdi      # 0x120fa
leaq 0xdf3f(%rip), %rsi      # 0x121e1
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4354
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x42fe
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x4322
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1043a
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rbx
jmp 0x428c
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xde2a(%rip), %rdi      # 0x12141
leaq 0xdec3(%rip), %rsi      # 0x121e1
xorl %edx, %edx
jmp 0x4347
callq 0xfc74
movq %rax, %r14
movl $0x4, %edi
callq 0xfc74
leaq 0xde06(%rip), %rdi      # 0x12141
leaq 0xde9f(%rip), %rsi      # 0x121e1
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4391
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x43b0
movq %rbx, %rax
jmp 0x4471
leaq 0xdd62(%rip), %rdi      # 0x120fa
leaq 0xde4b(%rip), %rsi      # 0x121ea
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4463
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
cmpl $0xa, %edi
jne 0x440d
movq 0x8(%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x4431
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1045f
movl %eax, %ebp
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rdi
callq 0x1029f
movzbl %bpl, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x10090
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xdd1b(%rip), %rdi      # 0x12141
leaq 0xddbd(%rip), %rsi      # 0x121ea
xorl %edx, %edx
jmp 0x4456
callq 0xfc74
movq %rax, %r14
movl $0x4, %edi
callq 0xfc74
leaq 0xdcf7(%rip), %rdi      # 0x12141
leaq 0xdd99(%rip), %rsi      # 0x121ea
movl $0x1, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x449a
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x44ca
movq %rbx, %rax
jmp 0x44c2
leaq 0xdc59(%rip), %rdi      # 0x120fa
leaq 0xdd4f(%rip), %rsi      # 0x121f7
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
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 0x44ef
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %rax, %rdi
callq 0x10475
jmp 0x44b4
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xdc39(%rip), %rdi      # 0x12141
leaq 0xdce8(%rip), %rsi      # 0x121f7
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x44b4
// File: /workspace/github_c_makefile_star2_O3/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 0x4544
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x4574
movq %rbx, %rax
jmp 0x456c
leaq 0xdbaf(%rip), %rdi      # 0x120fa
leaq 0xdcaf(%rip), %rsi      # 0x12201
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
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 0x4599
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movq %rax, %rdi
callq 0x10509
jmp 0x455e
callq 0xfc74
movq %rax, %r14
movl $0xa, %edi
callq 0xfc74
leaq 0xdb8f(%rip), %rdi      # 0x12141
leaq 0xdc48(%rip), %rsi      # 0x12201
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x455e
// File: /workspace/github_c_makefile_star2_O3/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 0x460c
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x4634
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0xc, %edi
ja 0x463f
movl $0x1430, %ecx           # imm = 0x1430
btl %edi, %ecx
jae 0x463f
movslq 0x10(%rax), %rdi
callq 0xff6f
jmp 0x4626
leaq 0xdae7(%rip), %rdi      # 0x120fa
leaq 0xdbf1(%rip), %rsi      # 0x1220b
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xfc74
leaq 0xdbc4(%rip), %rdi      # 0x1220f
leaq 0xdbb9(%rip), %rsi      # 0x1220b
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4626
// File: /workspace/github_c_makefile_star2_O3/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 0x4684
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x46b4
movq %rbx, %rax
jmp 0x46ac
leaq 0xda6f(%rip), %rdi      # 0x120fa
leaq 0xdbce(%rip), %rsi      # 0x12260
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
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 0x46e5
movl $0x1030, %eax           # imm = 0x1030
btl %edi, %eax
jae 0x46e5
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x108e4
callq 0xfc74
leaq 0xdb77(%rip), %rdi      # 0x12268
leaq 0xdb68(%rip), %rsi      # 0x12260
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfe6b
jmp 0x469e
// File: /workspace/github_c_makefile_star2_O3/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 0x4993
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5f11
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x49bb
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x6, %edi
jne 0x49c6
movzbl 0x18(%rax), %eax
movl $0x2, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x1075b
jmp 0x49ad
leaq 0xd760(%rip), %rdi      # 0x120fa
leaq 0xd988(%rip), %rsi      # 0x12329
movl $0x3, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xfc74
movq %rax, %r14
movl $0x6, %edi
callq 0xfc74
leaq 0xd762(%rip), %rdi      # 0x12141
leaq 0xd943(%rip), %rsi      # 0x12329
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x49ad
// File: /workspace/github_c_makefile_star2_O3/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 0x4edd
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rcx
movl (%rcx), %edi
leal -0xb(%rdi), %eax
cmpl $0x1, %eax
ja 0x4ef9
movslq 0x4(%rcx), %rax
testq %rax, %rax
jle 0x4eb3
movq 0x8(%rcx), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdx
cmpl $0x3, (%rdx)
jne 0x4f1a
incq %rsi
cmpq %rsi, %rax
jne 0x4ea2
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10111
leaq 0xd216(%rip), %rdi      # 0x120fa
leaq 0xd575(%rip), %rsi      # 0x12460
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4f28
callq 0xfc74
leaq 0xd55e(%rip), %rdi      # 0x12463
leaq 0xd554(%rip), %rsi      # 0x12460
xorl %edx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfe6b
jmp 0x4f28
leaq 0xd593(%rip), %rdi      # 0x124b4
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f9a
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movl (%rsi), %edi
cmpl $0x3, %edi
jne 0x4fb6
movq 0x8(%rax), %rax
movl (%rax), %edi
leal -0xb(%rdi), %eax
cmpl $0x2, %eax
jae 0x4fe7
movq %r14, %rdi
callq 0x113ff
movq 0x8(%rbx), %rcx
cmpl $-0x1, %eax
je 0x5023
movq (%rcx), %rax
movq 0x18(%rax), %rsi
leaq 0xd3a9(%rip), %rdi      # 0x1233a
xorl %eax, %eax
callq 0xfe6b
jmp 0x5009
leaq 0xd159(%rip), %rdi      # 0x120fa
leaq 0xd549(%rip), %rsi      # 0x124f1
movl $0x3, %edx
xorl %eax, %eax
callq 0xfe6b
jmp 0x5009
callq 0xfc74
movq %rax, %r14
movl $0x3, %edi
callq 0xfc74
leaq 0xd172(%rip), %rdi      # 0x12141
leaq 0xd51b(%rip), %rsi      # 0x124f1
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x5009
callq 0xfc74
leaq 0xd470(%rip), %rdi      # 0x12463
leaq 0xd4f7(%rip), %rsi      # 0x124f1
movl $0x1, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rcx), %rcx
movslq 0x4(%rcx), %rax
testq %rax, %rax
jle 0x5047
movq 0x8(%rcx), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdx
cmpl $0x3, (%rdx)
jne 0x50aa
incq %rsi
cmpq %rsi, %rax
jne 0x5036
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x101b5
movq %rax, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1145a
movq %r15, %rdi
callq 0x1029f
movq %rbx, %rdi
callq 0x1029f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10233
leaq 0xd446(%rip), %rdi      # 0x124f7
xorl %eax, %eax
callq 0xfe6b
jmp 0x5009
// File: /workspace/github_c_makefile_star2_O3/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 0x50fa
movq %rbx, %rsi
callq 0x5f58
movq %rax, %r14
cmpl $0x2, (%rax)
je 0x511f
movq %r14, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %rbx
movl (%rax), %edi
callq 0xfc92
movq %rax, %rdi
callq 0x10024
jmp 0x5114
leaq 0xcff9(%rip), %rdi      # 0x120fa
leaq 0xd424(%rip), %rsi      # 0x1252c
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x519f
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x5217
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x4, %edi
jne 0x51c9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %rax, %r15
movq 0x18(%r14), %rdi
callq 0xfcb0
movl %eax, %ebx
callq 0x2060
cmpl $0x16, (%rax)
jne 0x51fa
movq 0x18(%r14), %rsi
leaq 0xd3a5(%rip), %rdi      # 0x1253b
xorl %eax, %eax
callq 0xfe6b
jmp 0x5204
leaq 0xcf54(%rip), %rdi      # 0x120fa
leaq 0xd386(%rip), %rsi      # 0x12533
movl $0x2, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rax
jmp 0x521a
callq 0xfc74
movq %rax, %r14
movl $0x4, %edi
callq 0xfc74
leaq 0xcf5f(%rip), %rdi      # 0x12141
leaq 0xd34a(%rip), %rsi      # 0x12533
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x51b9
movl %ebx, %edi
movq %r15, %rsi
callq 0x10ba9
movq %rax, %rbx
movq %r14, %rdi
callq 0x1029f
movq %r15, %rdi
callq 0x1029f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
jne 0x54ee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x0, 0x4(%rbx)
jle 0x5542
leaq 0xd04e(%rip), %r14      # 0x12549
leaq 0xe050(%rip), %r15      # 0x13552
xorl %r12d, %r12d
testq %r12, %r12
je 0x5514
movq %r15, %rdi
xorl %eax, %eax
callq 0xf64e
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
cmpl $0x5, (%rdi)
jne 0x5531
movq 0x18(%rdi), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0xf64e
jmp 0x5536
callq 0xf73f
incq %r12
movslq 0x4(%rbx), %rax
cmpq %rax, %r12
jl 0x5505
movq %rbx, %rdi
callq 0x1029f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10233
// File: /workspace/github_c_makefile_star2_O3/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 0x5608
movq %rbx, %rsi
callq 0x5f58
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x5630
movq 0x8(%rbx), %rax
movq (%rax), %rax
movl (%rax), %edi
cmpl $0x5, %edi
jne 0x563b
movq 0x18(%rax), %rdi
xorl %eax, %eax
callq 0xfe6b
jmp 0x5622
leaq 0xcaeb(%rip), %rdi      # 0x120fa
leaq 0xcf8a(%rip), %rsi      # 0x125a0
movl $0x1, %edx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xfc74
movq %rax, %r14
movl $0x5, %edi
callq 0xfc74
leaq 0xcaed(%rip), %rdi      # 0x12141
leaq 0xcf45(%rip), %rsi      # 0x125a0
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfe6b
jmp 0x5622
// File: /workspace/github_c_makefile_star2_O3/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 0x569f
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x28, %edi
callq 0x2290
testq %rax, %rax
je 0x56f0
movq %rax, %rbx
movq $0x10, (%rax)
movl $0x1, %edi
movl $0x80, %esi
callq 0x2200
testq %rax, %rax
je 0x56f5
movq %rax, 0x8(%rbx)
movl $0x80, %edi
callq 0x2290
testq %rax, %rax
je 0x56fa
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x2494
callq 0x246f
callq 0x244a
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $0x0, (%rdi)
jle 0x573e
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5733
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5733
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x570e
movq 0x8(%rbx), %rdi
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_O3/voithos[P]awl/src/dict.c
// Function: dict_index
int dict_index(const dict* d, const char* k) {
    int i = dict_findslot(d, k);
    if (!d->syms[i]) {
        i = -1;
    }
    return i;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x577b
movq 0x8(%rbx), %rcx
cltq
xorl %edx, %edx
cmpq $0x1, (%rcx,%rax,8)
sbbl %edx, %edx
orl %edx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb (%rsi), %cl
testb %cl, %cl
je 0x57ae
leaq 0x1(%rbx), %rdx
movl $0x1505, %eax           # imm = 0x1505
movl %eax, %esi
shll $0x5, %esi
addl %eax, %esi
movsbl %cl, %eax
xorl %esi, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x5797
jmp 0x57b3
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
divl (%r14)
movl %edx, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x57f6
movl $0x1, %ebp
movq %rbx, %rsi
callq 0x11692
testb %al, %al
jne 0x57f6
addl %ebp, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl (%r14)
incl %ebp
movq 0x8(%r14), %rax
movl %edx, %r15d
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
jne 0x57cd
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
callq 0x577b
movq 0x8(%rbx), %r12
movslq %eax, %r14
cmpq $0x0, (%r12,%r14,8)
je 0x58ad
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x588e
movq %r13, %rdi
callq *%rax
movq %rax, %r13
movq 0x20(%rbx), %rax
addq $0x10, %rbx
testq %rax, %rax
je 0x59f4
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rdi
callq *%rax
jmp 0x59f4
movl %eax, %ebp
movl 0x4(%rbx), %eax
incl %eax
movl %eax, 0x4(%rbx)
cvtsi2ss %eax, %xmm0
movslq (%rbx), %r14
cvtsi2ss %r14d, %xmm1
divss %xmm1, %xmm0
ucomiss 0xcd0e(%rip), %xmm0     # 0x125dc
jb 0x59ae
movq %r13, 0x10(%rsp)
leal (%r14,%r14), %eax
movl %eax, 0xc(%rsp)
movl %eax, (%rbx)
movq 0x10(%rbx), %r13
movq %r14, %rbp
shlq $0x4, %rbp
movq %rbp, %rdi
callq 0x2290
testq %rax, %rax
je 0x5a0f
movq %rax, 0x8(%rbx)
testl %r14d, %r14d
jle 0x5977
movl 0xc(%rsp), %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movq $0x0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x590e
movq %rbp, %rdi
callq 0x2290
testq %rax, %rax
je 0x5a14
movq %rax, 0x10(%rbx)
testl %r14d, %r14d
jle 0x598c
xorl %ebp, %ebp
movq (%r12,%rbp,8), %rsi
testq %rsi, %rsi
je 0x596d
movq (%r13,%rbp,8), %rdx
movq %rbx, %rdi
callq 0x5853
movq (%r12,%rbp,8), %rdi
callq 0x23f0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x596d
movq (%r13,%rbp,8), %rdi
callq *%rax
incq %rbp
cmpq %rbp, %r14
jne 0x593e
jmp 0x598c
movq %rbp, %rdi
callq 0x2290
testq %rax, %rax
je 0x5a14
movq %rax, 0x10(%rbx)
movq %r12, %rdi
callq 0x23f0
movq %r13, %rdi
callq 0x23f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x577b
movl %eax, %ebp
movq 0x10(%rsp), %r13
movq %r15, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2290
testq %rax, %rax
je 0x5a0a
movq 0x8(%rbx), %rcx
movslq %ebp, %r14
movq %rax, (%rcx,%r14,8)
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0x2080
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x59f0
movq %r13, %rdi
callq *%rax
movq %rax, %r13
addq $0x10, %rbx
movq (%rbx), %rax
movq %r13, (%rax,%r14,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2503
callq 0x24de
callq 0x24b9
// File: /workspace/github_c_makefile_star2_O3/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 0x577b
movq 0x8(%rbx), %rcx
movslq %eax, %r14
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x5a64
decl 0x4(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x5a53
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
movq $0x0, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x28, %edi
callq 0x2290
testq %rax, %rax
je 0x5b2e
movq %rax, %rbx
movslq (%r14), %r12
movl %r12d, (%rax)
movl $0x0, 0x4(%rax)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rax)
movq %r12, %r15
shlq $0x3, %r15
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x5b33
movq %rax, 0x8(%rbx)
testl %r12d, %r12d
jle 0x5b0e
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2170
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x5b38
movq %rax, 0x10(%rbx)
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
testq %rsi, %rsi
je 0x5b01
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
callq 0x5853
movl (%r14), %r12d
incq %r15
movslq %r12d, %rax
cmpq %rax, %r15
jl 0x5ae1
jmp 0x5b1f
movq %r15, %rdi
callq 0x2290
testq %rax, %rax
je 0x5b38
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2572
callq 0x254d
callq 0x2528
// File: /workspace/github_c_makefile_star2_O3/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 0x2290
testq %rax, %rax
je 0x5b83
movslq (%rbx), %rcx
testq %rcx, %rcx
jle 0x5b81
movq 0x8(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
movq (%rdx,%rsi,8), %r8
testq %r8, %r8
je 0x5b79
movslq %edi, %r9
incl %edi
movq %r8, (%rax,%r9,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x5b67
popq %rbx
retq
callq 0x2597
// File: /workspace/github_c_makefile_star2_O3/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 0x2290
testq %rax, %rax
je 0x5bd0
movslq (%rbx), %rcx
testq %rcx, %rcx
jle 0x5bce
movq 0x8(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x0, (%rdx,%rsi,8)
je 0x5bc6
movq 0x10(%rbx), %r8
movq (%r8,%rsi,8), %r8
movslq %edi, %r9
incl %edi
movq %r8, (%rax,%r9,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x5bae
popq %rbx
retq
callq 0x25bc
// File: /workspace/github_c_makefile_star2_O3/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 0x5d9a
movq %rdi, %r15
xorl %edx, %edx
callq 0x5f11
movq %rax, %rbx
cmpl $0x2, (%rax)
je 0x5d95
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1075b
movq %rax, %r14
movl (%rax), %eax
addl $-0x7, %eax
cmpl $0x3, %eax
jae 0x5dc2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5fc1
movq %rax, %rbx
movq %r14, %rdi
callq 0x1029f
movq %rbx, %rax
jmp 0x5e01
movq %rsi, %rdi
callq 0x1029f
movl $0xb, %edi
callq 0xfc74
leaq 0xc873(%rip), %rdi      # 0x12626
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0xfe6b
movl $0xb, %edi
callq 0xfc74
movq %rax, %r15
movl (%r14), %edi
callq 0xfc74
leaq 0xc861(%rip), %rdi      # 0x1263f
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfe6b
movq %rax, %r15
movq %rbx, %rdi
callq 0x1029f
movq %r14, %rdi
callq 0x1029f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movl (%rsi), %eax
leal -0xb(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5ebf
cmpl $0x0, 0x4(%rbx)
jle 0x5f02
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpl $0xe, (%rsi)
jne 0x5e80
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1075b
movq %rax, %rdi
xorl %esi, %esi
callq 0x107b7
movq %r14, %rdi
movq %rax, %rsi
callq 0x5be8
movq %rax, %r12
movl (%rax), %eax
movq %rbx, %rdi
cmpl $0xc, %eax
je 0x5e9f
cmpl $0x2, %eax
je 0x5efa
movq %r12, %rsi
movl %r15d, %edx
callq 0x1083b
jmp 0x5eaa
movq %r14, %rdi
callq 0x5e07
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x5ead
jmp 0x5ee4
movq %r12, %rsi
movl %r15d, %edx
callq 0x108a2
movq %rax, %rbx
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x5e30
jmp 0x5f02
cmpl $0xd, %eax
jne 0x5f02
movq %rbx, %rdi
xorl %esi, %esi
callq 0x107b7
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5be8
movq %rbx, %rdi
movl %r15d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x107b7
callq 0x1029f
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5be8
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpl $0x2, (%rax)
jne 0x5f4f
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x107b7
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpl $0x0, 0x4(%rsi)
jle 0x5fab
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x5be8
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x5f6c
testl %eax, %eax
jle 0x5fab
movq 0x8(%rbx), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdx
cmpl $0x2, (%rdx)
je 0x5fb4
incq %rsi
cmpq %rsi, %rax
jne 0x5f9a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x107b7
// File: /workspace/github_c_makefile_star2_O3/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 0x10b56
movq %rax, %r14
movq 0x28(%rbx), %rdi
callq 0x10597
movq %r14, %rdi
movq %rax, %rsi
callq 0x5be8
movq %rax, %rbx
movq %r14, %rdi
callq 0x1032e
cmpl $0xc, (%rbx)
jne 0x62b1
movl $0xb, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6b84
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_O3/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 0x2cba
callq 0x10efb
movq %rax, %rbx
movq %rax, %rdi
cmpl $0x1, %ebp
jne 0x79d5
callq 0xfb96
jmp 0x79df
movl %ebp, %esi
movq %r14, %rdx
callq 0x2c4c
movq %rbx, %rdi
callq 0x113ef
callq 0x2cd4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x8b84
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x9f2b(%rip), %xmm0     # 0x12a78
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
movl $0x0, -0x4(%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd 0x9e92(%rip), %xmm1     # 0x12a78
callq 0x20f0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x8c40
movl 0x4(%rbx), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x9e75(%rip), %xmm0     # 0x12a80
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_O3/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 0x8cab
incl %eax
cvtsi2sd %eax, %xmm0
mulsd 0x9e07(%rip), %xmm0     # 0x12a78
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