LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: print
void print(Stack s){
    assert(s!=NULL);
    if(isEmpty(s)){
        printf("stack is empty.\n");
    }else{
    	int i;
        for(i=s->top;i>=0;i--){
            printf("[%d]--%d\n",i, s->data[i]);
        }
        printf("\n"); 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1555
jmp 0x1574
leaq 0xad5(%rip), %rdi       # 0x2031
leaq 0xad6(%rip), %rsi       # 0x2039
movl $0x4b, %edx
leaq 0xb74(%rip), %rcx       # 0x20e3
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x12e0
cmpl $0x0, %eax
je 0x1592
leaq 0xb6c(%rip), %rdi       # 0x20f5
movb $0x0, %al
callq 0x1040
jmp 0x15db
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x15cd
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xb4b(%rip), %rdi       # 0x2106
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x159c
leaq 0xb30(%rip), %rdi       # 0x2104
movb $0x0, %al
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: main
int main(int argc, char **argv)
{
    Stack s=create(10);
    int i;
    for(i=0;i<10;i++){
        push(rand()%100,s);
    }
    printf("Stack Size: %d\n", s->size);
    printf("Stack Top: %d\n", s->top);
    print(s);
    pop(s);
    pop(s);
    print(s);
    printf("topAndPop: %d\n",topAndPop(s));
    print(s);
    clear(s);
    print(s);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, %edi
callq 0x1190
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x1644
callq 0x1080
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, %edi
movq -0x18(%rbp), %rsi
callq 0x1360
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x161b
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0xabf(%rip), %rdi       # 0x2110
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0xaba(%rip), %rdi       # 0x2120
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1540
movq -0x18(%rbp), %rdi
callq 0x13e0
movq -0x18(%rbp), %rdi
callq 0x13e0
movq -0x18(%rbp), %rdi
callq 0x1540
movq -0x18(%rbp), %rdi
callq 0x14c0
movl %eax, %esi
leaq 0xa8c(%rip), %rdi       # 0x212f
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1540
movq -0x18(%rbp), %rdi
callq 0x1240
movq -0x18(%rbp), %rdi
callq 0x1540
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/common.c
// Function: lake_str_append
char *lake_str_append(char *s1, char *s2)
{
    size_t n2 = strlen(s2);
    s1 = realloc(s1, strlen(s1) + n2 + 1);
    strncat(s1, s2, n2);
    return s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x11a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1100
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/comment.c
// Function: comment_alloc
static LakeComment *comment_alloc(void)
{
    LakeComment *comment = malloc(sizeof(LakeComment));
    VAL(comment)->type = TYPE_COMM;
    VAL(comment)->size = sizeof(LakeComment);
    return comment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x9, (%rax)
movq -0x8(%rbp), %rax
movq $0x18, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/dlist.c
// Function: dlist_make
LakeDottedList *dlist_make(LakeList *head, LakeVal *tail)
{
    LakeDottedList *dlist = dlist_alloc();
    dlist->head = head;
    dlist->tail = tail;
    return dlist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x16b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/dlist.c
// Function: dlist_alloc
static LakeDottedList *dlist_alloc(void)
{
    LakeDottedList *dlist = malloc(sizeof(LakeDottedList));
    VAL(dlist)->type = TYPE_DLIST;
    VAL(dlist)->size = sizeof(LakeDottedList);
    return dlist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6, (%rax)
movq -0x8(%rbp), %rax
movq $0x20, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/dlist.c
// Function: dlist_repr
char *dlist_repr(LakeDottedList *dlist)
{
    char *s = malloc(2);
    s[0] = '(';
    s[1] = '\0';
    int i;
    char *s2;
    if (dlist->head && LIST_N(dlist->head))
    {
        for (i = 0; i < LIST_N(dlist->head); ++i)
        {
            s2 = lake_repr(LIST_VAL(dlist->head, i));
            s = lake_str_append(s, s2);
            free(s2);
            if (i != LIST_N(dlist->head) - 1) s = lake_str_append(s, " ");
        }
    }
    else if (dlist->head)
    {
        s2 = lake_repr(dlist->head);
        s = lake_str_append(s, s2);
        free(s2);
    }
    s = lake_str_append(s, " . ");
    s2 = lake_repr(dlist->tail);
    s = lake_str_append(s, s2);
    free(s2);
    return lake_str_append(s, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x28, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1838
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x1838
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1836
cmpl $0x0, -0x14(%rbp)
jl 0x17ca
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jae 0x17ca
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x17d2
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x17d2
movq -0x28(%rbp), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x1826
movq -0x10(%rbp), %rdi
leaq 0x77ef(%rip), %rsi      # 0x900c
callq 0x12f0
movq %rax, -0x10(%rbp)
jmp 0x1828
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1782
jmp 0x1870
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x186e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x1870
movq -0x10(%rbp), %rdi
leaq 0x778f(%rip), %rsi      # 0x900a
callq 0x12f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
leaq 0x7ad7(%rip), %rsi      # 0x9391
callq 0x12f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/dlist.c
// Function: dlist_equal
bool dlist_equal(LakeDottedList *a, LakeDottedList *b)
{
    LakeVal *headA = VAL(dlist_head(a));
    LakeVal *tailA = dlist_tail(a);
    LakeVal *headB = VAL(dlist_head(b));
    LakeVal *tailB = dlist_tail(b);
    return lake_equal(headA, headB) && lake_equal(tailA, tailB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16f0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1710
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1710
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4360
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x1943
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x4360
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/env.c
// Function: env_make
Env *env_make(Env *parent)
{
    Env *env = malloc(sizeof(Env));
    env->parent = parent;
    env->bindings = lake_hash_make();
    return env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x1b40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/env.c
// Function: env_set
LakeVal *env_set(Env *env, LakeSym *key, LakeVal *val)
{
    Env *definedEnv;
    if (!(definedEnv = env_is_defined(env, key)))
    {
        return NULL;
    }
    env_put(definedEnv, key, val);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1ab5
movq $0x0, -0x8(%rbp)
jmp 0x1ace
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1a40
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/env.c
// Function: env_get
LakeVal *env_get(Env *env, LakeSym *key)
{
    LakeVal *val = lake_hash_get(env->bindings, key->s);
    if (!val && env->parent)
    {
        val = env_get(env->parent, key);
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x38c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b2e
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1b2e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ae0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: init_special_form_handlers
void init_special_form_handlers(LakeCtx *ctx)
{
    /* define_handler(ctx, "load", &load_special_form); */
    define_handler(ctx, "quote", &_quote);
    define_handler(ctx, "and", &_and);
    define_handler(ctx, "or", &_or);
    define_handler(ctx, "if", &_if);
    define_handler(ctx, "when", &_when);
    define_handler(ctx, "cond", &_cond);
    define_handler(ctx, "set!", &_setB);
    define_handler(ctx, "define", &_define);
    define_handler(ctx, "lambda", &_lambda);
    /* define_handler(ctx, "let", &_let); */
    /* define_handler(ctx, "let!", &_letB); */
    /* define_handler(ctx, "letrec", &_letrec); */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x74bd(%rip), %rsi      # 0x9034
leaq 0x102(%rip), %rdx       # 0x1c80
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x74ac(%rip), %rsi      # 0x903a
leaq 0x13b(%rip), %rdx       # 0x1cd0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x7a56(%rip), %rsi      # 0x95fb
leaq 0x224(%rip), %rdx       # 0x1dd0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x7482(%rip), %rsi      # 0x903e
leaq 0x30d(%rip), %rdx       # 0x1ed0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x746e(%rip), %rsi      # 0x9041
leaq 0x406(%rip), %rdx       # 0x1fe0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x745c(%rip), %rsi      # 0x9046
leaq 0x4af(%rip), %rdx       # 0x20a0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x744a(%rip), %rsi      # 0x904b
leaq 0x5b8(%rip), %rdx       # 0x21c0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x7438(%rip), %rsi      # 0x9050
leaq 0x6c1(%rip), %rdx       # 0x22e0
callq 0x1c50
movq -0x8(%rbp), %rdi
leaq 0x7428(%rip), %rsi      # 0x9057
leaq 0x92a(%rip), %rdx       # 0x2560
callq 0x1c50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: quote
static LakeVal *_quote(LakeCtx *ctx, Env *env, LakeList *expr)
{
    if (LIST_N(expr) == 2)
    {
        return list_pop(expr);
    }
    invalid_special_form(expr, "quote requires exactly one parameter");
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jne 0x1cae
movq -0x20(%rbp), %rdi
callq 0x4b20
movq %rax, -0x8(%rbp)
jmp 0x1cc6
movq -0x20(%rbp), %rdi
leaq 0x7479(%rip), %rsi      # 0x9132
callq 0x3210
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: and
static LakeVal *_and(LakeCtx *ctx, Env *env, LakeList *expr)
{
    /* drop the "and" symbol */
    list_shift(expr);

    /* (and ...) */
    LakeVal *result =
        LIST_N(expr) ? eval(ctx, env, list_shift(expr)) : VAL(ctx->T);
    while (lake_is_truthy(ctx, result) && LIST_N(expr) > 0)
    {
        result = lake_bool_and(ctx, result, eval(ctx, env, list_shift(expr)));
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1d27
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq %rax, -0x28(%rbp)
jmp 0x1d33
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x1d63
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
seta %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1d6c
jmp 0x1dbb
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x15c0
movq %rax, -0x20(%rbp)
jmp 0x1d3b
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: or
static LakeVal *_or(LakeCtx *ctx, Env *env, LakeList *expr)
{
    /* drop the "or" symbol */
    list_shift(expr);

    /* (or ...) */
    LakeVal *result =
        LIST_N(expr) ? eval(ctx, env, list_shift(expr)) : VAL(ctx->F);
    while (lake_is_falsy(ctx, result) && LIST_N(expr) > 0)
    {
        result = lake_bool_or(ctx, result, eval(ctx, env, list_shift(expr)));
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1e27
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq %rax, -0x28(%rbp)
jmp 0x1e33
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1510
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x1e63
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
seta %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x1e6c
jmp 0x1ebb
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x1620
movq %rax, -0x20(%rbp)
jmp 0x1e3b
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: if
static LakeVal *_if(LakeCtx *ctx, Env *env, LakeList *expr)
{
    if (LIST_N(expr) != 3)
    {
        invalid_special_form(expr, "if requires 3 parameters");
        return NULL;
    }
    list_shift(expr); /* "if" token */
    LakeVal *cond = eval(ctx, env, list_shift(expr));
    if (lake_is_truthy(ctx, cond))
    {
        return eval(ctx, env, list_shift(expr));
    }
    else
    {
        return eval(ctx, env, LIST_VAL(expr, 1));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x3, 0x18(%rax)
je 0x1f0c
movq -0x20(%rbp), %rdi
leaq 0x727c(%rip), %rsi      # 0x9176
callq 0x3210
movq $0x0, -0x8(%rbp)
jmp 0x1fd1
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14e0
cmpl $0x0, %eax
je 0x1f83
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq %rax, -0x8(%rbp)
jmp 0x1fd1
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rcx
movl $0x1, %eax
cmpq 0x18(%rcx), %rax
jae 0x1fb4
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x1fbc
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x1fbc
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
callq 0x2840
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: when
static LakeVal *_when(LakeCtx *ctx, Env *env, LakeList *expr)
{
    if (LIST_N(expr) < 2)
    {
        invalid_special_form(expr, "when requires at least 2 parameters");
        return NULL;
    }
    list_shift(expr); /* "when" token */
    LakeVal *cond = eval(ctx, env, list_shift(expr));
    return lake_is_truthy(ctx, cond) ? eval_exprs1(ctx, env, expr) : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jae 0x2019
movq -0x20(%rbp), %rdi
leaq 0x7185(%rip), %rsi      # 0x918f
callq 0x3210
movq $0x0, -0x8(%rbp)
jmp 0x2088
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x2840
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x14e0
cmpl $0x0, %eax
je 0x2078
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x31c0
movq %rax, -0x40(%rbp)
jmp 0x2080
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x2080
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: cond
static LakeVal *_cond(LakeCtx *ctx, Env *env, LakeList *expr)
{
    static LakeVal *ELSE = NULL;
    if (!ELSE) ELSE = VAL(sym_intern(ctx, "else"));

    list_shift(expr); /* "cond" token */
    LakeVal *pred;
    LakeList *conseq;
    while (LIST_N(expr))
    {
        if (!lake_is_type(TYPE_LIST, LIST_VAL(expr, 0)))
        {
            invalid_special_form(expr,
                                 "expected a (predicate consequence) pair");
            return NULL;
        }
        conseq = LIST(list_shift(expr));
        pred = list_shift(conseq);
        if (pred == ELSE || lake_is_truthy(ctx, eval(ctx, env, pred)))
        {
            return eval_exprs1(ctx, env, conseq);
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, 0xb0ac(%rip)      # 0xd168
jne 0x20d5
movq -0x10(%rbp), %rdi
leaq 0x70ea(%rip), %rsi      # 0x91b3
callq 0x7f30
movq %rax, 0xb093(%rip)      # 0xd168
movq -0x20(%rbp), %rdi
callq 0x4a90
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x21ac
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x210a
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2112
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2112
movq -0x38(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x213f
movq -0x20(%rbp), %rdi
leaq 0x7088(%rip), %rsi      # 0x91b8
callq 0x3210
movq $0x0, -0x8(%rbp)
jmp 0x21b4
movq -0x20(%rbp), %rdi
callq 0x4a90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x4a90
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0xb004(%rip), %rax      # 0xd168
je 0x2190
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2840
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x14e0
cmpl $0x0, %eax
je 0x21a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x31c0
movq %rax, -0x8(%rbp)
jmp 0x21b4
jmp 0x20de
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: setB
static LakeVal *_setB(LakeCtx *ctx, Env *env, LakeList *expr)
{
    /* (set! x 42) */
    if (LIST_N(expr) == 3 && lake_is_type(TYPE_SYM, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "set!" symbol */
        LakeSym *var = SYM(list_shift(expr));
        LakeVal *form = list_shift(expr);
        if (!env_set(env, var, form))
        {
            ERR("%s is not defined", sym_repr(var));
        }
    }
    else
    {
        invalid_special_form(expr, "set! requires exactly 2 parameters");
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x3, 0x18(%rax)
jne 0x22bf
movq -0x18(%rbp), %rcx
movl $0x1, %eax
cmpq 0x18(%rcx), %rax
jae 0x2204
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x220c
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x220c
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x22bf
movq -0x18(%rbp), %rdi
callq 0x4a90
movq -0x18(%rbp), %rdi
callq 0x4a90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4a90
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1a80
cmpq $0x0, %rax
jne 0x22bd
jmp 0x225f
movq 0xad92(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x6dee(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0xad7a(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x80a0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x6f44(%rip), %rsi      # 0x91e0
movb $0x0, %al
callq 0x1160
movq 0xad4e(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x712c(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
jmp 0x22bd
jmp 0x22cf
movq -0x18(%rbp), %rdi
leaq 0x6f28(%rip), %rsi      # 0x91f2
callq 0x3210
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: eval_special_form
static LakeVal *eval_special_form(LakeCtx *ctx, Env *env, LakeList *expr)
{
    LakeSym *name = SYM(LIST_VAL(expr, 0));
    special_form_handler handler = get_special_form_handler(ctx, name);
    if (handler)
    {
        return handler(ctx, env, list_copy(expr));
    }
    ERR("unrecognized special form: %s", sym_repr(name));
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x2c01
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2c09
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x2c09
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3290
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x2c61
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4910
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
movq -0x40(%rbp), %rax
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x2cc7
jmp 0x2c63
movq 0xa38e(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x63ea(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0xa376(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x80a0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0x65c1(%rip), %rsi      # 0x9261
movb $0x0, %al
callq 0x1160
movq 0xa34a(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x6728(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: eval_exprs
LakeList *eval_exprs(LakeCtx *ctx, Env *env, LakeList *exprs)
{
    LakeList *results = list_make_with_capacity(LIST_N(exprs));
    int i;
    for (i = 0; i < LIST_N(exprs); ++i)
    {
        list_append(results, eval(ctx, env, LIST_VAL(exprs, i)));
    }
    return results;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4680
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x31ac
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x317c
movslq -0x24(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x317c
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x3184
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x3184
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
callq 0x2840
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x47f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x312c
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/eval.c
// Function: eval_exprs1
LakeVal *eval_exprs1(LakeCtx *ctx, Env *env, LakeList *exprs)
{
    LakeList *results = eval_exprs(ctx, env, exprs);
    LakeVal *result = list_pop(results);
    list_free(results);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4b20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4610
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/fn.c
// Function: fn_make
LakeFn *fn_make(LakeList *params, LakeSym *varargs, LakeList *body,
                Env *closure)
{
    LakeFn *fn = fn_alloc();
    fn->params = params;
    fn->varargs = varargs;
    fn->body = body;
    fn->closure = closure;
    return fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x3320
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/fn.c
// Function: fn_alloc
static LakeFn *fn_alloc(void)
{
    LakeFn *fn = malloc(sizeof(LakeFn));
    VAL(fn)->type = TYPE_FN;
    VAL(fn)->size = sizeof(LakeFn);
    return fn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movq $0x30, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/./khash.h
// Function: _ac_X31_hash_string
static inline khint_t __ac_X31_hash_string(const char *s)
{
    khint_t h = *s;
    if (h)
        for (++s; *s; ++s)
            h = (h << 5) - h + *s;
    return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3f92
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3f90
movl -0xc(%rbp), %eax
shll $0x5, %eax
subl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3f64
jmp 0x3f92
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/int.c
// Function: int_to_str
LakeStr *int_to_str(LakeInt *i)
{
    char *s = int_repr(i);
    LakeStr *str = lake_str_from_c(s);
    free(s);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4020
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/lake.c
// Function: lake_repr
char *lake_repr(void *expr)
{
    if (expr == NULL) return strdup("(null)");

    char *s = NULL;

    LakeVal *e = VAL(expr);
    switch (e->type)
    {

    case TYPE_SYM:
        s = sym_repr(SYM(e));
        break;

    case TYPE_BOOL:
        s = lake_bool_repr(BOOL(e));
        break;

    case TYPE_INT:
        s = int_repr(INT(e));
        break;

    case TYPE_STR:
    {
        // +3 for surrounding quotes and null terminator
        size_t n = strlen(STR_S(STR(e))) + 3;
        s = malloc(n);
        /* TODO: quote the string */
        snprintf(s, n, "\"%s\"", STR_S(STR(e)));
        break;
    }

    case TYPE_LIST:
        s = list_repr(LIST(e));
        break;

    case TYPE_DLIST:
        s = dlist_repr(DLIST(e));
        break;

    case TYPE_PRIM:
        s = prim_repr(PRIM(e));
        break;

    case TYPE_FN:
        s = fn_repr(FN(e));
        break;

    case TYPE_COMM:
        s = comment_repr(COMM(e));
        break;

    default:
        // If it wasn't a LakeVal we already crashed at the beginning of the
        // switch, so go ahead and print out the size too.
        fprintf(stderr, "error: unrecognized value, type %d, size %zu bytes",
                e->type, e->size);
        s = strdup("(unknown)");
    }

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4118
leaq 0x51da(%rip), %rdi      # 0x92e4
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x4257
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x8, %eax
ja 0x4219
movq -0x30(%rbp), %rax
leaq 0x5152(%rip), %rcx      # 0x929c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
callq 0x80a0
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x1580
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x4020
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10b0
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x5129(%rip), %rdx      # 0x92eb
movb $0x0, %al
callq 0x10e0
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x4cc0
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x1730
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x5e20
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x3360
movq %rax, -0x18(%rbp)
jmp 0x424f
movq -0x20(%rbp), %rdi
callq 0x1400
movq %rax, -0x18(%rbp)
jmp 0x424f
movq 0x8dd8(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x50b8(%rip), %rsi      # 0x92f0
movb $0x0, %al
callq 0x1160
leaq 0x50dd(%rip), %rdi      # 0x9323
callq 0x11d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/lake.c
// Function: lake_is
bool lake_is(LakeVal *a, LakeVal *b)
{
    if (lake_is_type(TYPE_INT, a) && lake_is_type(TYPE_INT, b))
    {
        return INT_VAL(INT(a)) == INT_VAL(INT(b));
    }
    if (lake_is_nil(a) && lake_is_nil(b)) return TRUE;
    return a == b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x4311
movq -0x18(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x4311
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4349
movq -0x10(%rbp), %rdi
callq 0x4270
cmpl $0x0, %eax
je 0x4336
movq -0x18(%rbp), %rdi
callq 0x4270
cmpl $0x0, %eax
je 0x4336
movl $0x1, -0x4(%rbp)
jmp 0x4349
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/lake.c
// Function: lake_equal
bool lake_equal(LakeVal *a, LakeVal *b)
{
    if (a->type != b->type) return FALSE;
    switch (a->type)
    {

    /* singletons can be compared directly */
    case TYPE_SYM:
    case TYPE_BOOL:
    case TYPE_PRIM:
    case TYPE_FN:
        return a == b;

    case TYPE_INT:
        return INT_VAL(INT(a)) == INT_VAL(INT(b));

    case TYPE_STR:
        return lake_str_equal(STR(a), STR(b));

    case TYPE_LIST:
        return list_equal(LIST(a), LIST(b));

    case TYPE_DLIST:
        return dlist_equal(DLIST(a), DLIST(b));

    case TYPE_COMM:
        return comment_equal(COMM(a), COMM(b));

    default:
        ERR("unknown type %d (%s)", a->type, type_name(a));
        return FALSE;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x438a
movl $0x0, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x8, %eax
ja 0x443c
movq -0x20(%rbp), %rax
leaq 0x4f14(%rip), %rcx      # 0x92c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7e80
movl %eax, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4b70
movl %eax, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18d0
movl %eax, -0x4(%rbp)
jmp 0x44ad
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1430
movl %eax, -0x4(%rbp)
jmp 0x44ad
jmp 0x443e
movq 0x8bb3(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x4c0f(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x8b9b(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44c0
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movq %rax, %rcx
leaq 0x4ea6(%rip), %rsi      # 0x932d
movb $0x0, %al
callq 0x1160
movq 0x8b63(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x4f41(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/lake.c
// Function: lake_init
LakeCtx *lake_init(void)
{
    LakeCtx *ctx = malloc(sizeof(LakeCtx));
    ctx->toplevel = env_make(NULL);
    ctx->symbols = lake_hash_make();
    ctx->special_form_handlers = lake_hash_make();
    ctx->T = bool_make(TRUE);
    ctx->F = bool_make(FALSE);
    bind_primitives(ctx);
    init_special_form_handlers(ctx);
    return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1960
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x45f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x45f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %edi
callq 0x45a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
xorl %edi, %edi
callq 0x45a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x5e90
movq -0x8(%rbp), %rdi
callq 0x1b60
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/lake.c
// Function: bool_make
static LakeBool *bool_make(bool val)
{
    LakeBool *b = malloc(sizeof(LakeBool));
    VAL(b)->type = TYPE_BOOL;
    VAL(b)->size = sizeof(LakeBool);
    b->val = val;
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x18, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movq $0x18, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_make_with_capacity
LakeList *list_make_with_capacity(size_t cap)
{
    LakeList *list = list_alloc();
    list->cap = cap;
    list->n = 0;
    list->vals = malloc(cap * sizeof(LakeVal *));
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x4850
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_cons
LakeList *list_cons(LakeVal *car, LakeVal *cdr)
{
    LakeList *list;
    if (lake_is_type(TYPE_LIST, cdr))
    {
        list = LIST(cdr);
        list_unshift(list, car);
    }
    else
    {
        list = list_make_with_capacity(2);
        list_append(list, car);
        list_append(list, cdr);
    }
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x470a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4740
jmp 0x4732
movl $0x2, %edi
callq 0x4680
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_unshift
LakeVal *list_unshift(LakeList *list, LakeVal *val)
{
    if (list->n == 0)
    {
        list_append(list, val);
    }
    else
    {
        if (list->n >= list->cap)
        {
            list_grow(list);
        }
        size_t i = list->n++;
        do
        {
            list->vals[i] = list->vals[i - 1];
        } while (i--);
        list->vals[0] = val;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x476a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47f0
jmp 0x47e4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4785
movq -0x8(%rbp), %rdi
callq 0x49d0
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x479c
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_append
LakeVal *list_append(LakeList *list, LakeVal *val)
{
    if (list->n >= list->cap)
    {
        list_grow(list);
    }
    list->vals[list->n++] = val;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x481b
movq -0x8(%rbp), %rdi
callq 0x49d0
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x18(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x18(%rsi)
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_alloc
static LakeList *list_alloc(void)
{
    LakeList *list = malloc(sizeof(LakeList));
    VAL(list)->type = TYPE_LIST;
    VAL(list)->size = sizeof(LakeList);
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq $0x28, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_from_array
LakeList *list_from_array(size_t n, LakeVal *vals[])
{
    LakeList *list = list_make_with_capacity(n);
    memcpy(list->vals, vals, n * sizeof(LakeVal *));
    list->n = n;
    return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4680
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
shlq $0x3, %rdx
callq 0x1180
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_get
LakeVal *list_get(LakeList *list, LakeInt *li)
{
    int i = INT_VAL(li);
    if (i >= 0 && i < list->n)
    {
        return list->vals[i];
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x49c0
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x49c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x49c8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_shift
LakeVal *list_shift(LakeList *list)
{
    LakeVal *head = NULL;
    if (list->n > 0)
    {
        head = list->vals[0];
        size_t i;
        size_t n = list->n;
        for (i = 1; i < n; ++i)
        {
            list->vals[i - 1] = list->vals[i];
        }
        list->n--;
    }
    return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x4b1a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4b0a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4ace
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/list.c
// Function: list_pop
LakeVal *list_pop(LakeList *list)
{
    LakeVal *tail = NULL;
    if (list->n > 0)
    {
        tail = list->vals[list->n - 1];
        list->n--;
    }
    return tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x4b67
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)