LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/uint256.c
// Function: tostring128
bool tostring128(const uint128_t *number, uint32_t baseParam, char *out,
                 uint32_t outLength) {
    if ((baseParam < 2) || (baseParam > 36)) {
        return false;
    }
    uint128_t rDiv;
    uint128_t rMod;
    uint128_t base;
    copy128(&rDiv, number);
    clear128(&base);
    LOWER(base) = baseParam;
    uint32_t offset = 0;
    do {
        if (offset > (outLength - 1)) {
            return false;
        }
        divmod128(&rDiv, &base, &rDiv, &rMod);
        out[offset++] = HEXDIGITS[LOWER(rMod)];
    } while (!zero128(&rDiv));
    out[offset] = '\0';
    reverseString(out, offset);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leal -0x25(%rsi), %eax
cmpl $-0x23, %eax
jae 0x53e4
xorl %ebp, %ebp
jmp 0x5487
movl %ecx, %r14d
movq %rdx, %rbx
movq (%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movl %esi, %eax
movq %rax, 0x8(%rcx)
decl %r14d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0x1df4(%rip), %r13      # 0x7210
incl %r12d
cmpl %r14d, %r12d
setbe %bpl
ja 0x5487
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
leaq 0x28(%rsp), %rcx
callq 0x49ba
movq 0x30(%rsp), %rax
movb (%rax,%r13), %cl
movl %r12d, %eax
movb %cl, (%rbx,%rax)
movq (%rsp), %rcx
orq 0x8(%rsp), %rcx
jne 0x541c
leal 0x1(%r12), %ecx
movb $0x0, (%rbx,%rcx)
testl %r12d, %r12d
je 0x5487
decq %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb 0x1(%rbx,%rax), %sil
movb %sil, (%rbx,%rcx)
movb %dl, 0x1(%rbx,%rax)
incq %rcx
movl %eax, %edx
decq %rax
cmpq %rdx, %rcx
jb 0x546a
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wjmelements[P]evm/src/uint256.c
// Function: tostring256
bool tostring256(const uint256_t *number, uint32_t baseParam, char *out,
                 uint32_t outLength) {
    if ((baseParam < 2) || (baseParam > 36)) {
        return false;
    }
    uint256_t rDiv;
    uint256_t rMod;
    uint256_t base;
    copy256(&rDiv, number);
    clear256(&base);
    UPPER(LOWER(base)) = 0;
    LOWER(LOWER(base)) = baseParam;
    uint32_t offset = 0;
    do {
        if (offset > (outLength - 1)) {
            return false;
        }
        divmod256(&rDiv, &base, &rDiv, &rMod);
        out[offset++] = HEXDIGITS[LOWER(LOWER(rMod))];
    } while (!zero256(&rDiv));
    out[offset] = '\0';
    reverseString(out, offset);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leal -0x25(%rsi), %eax
cmpl $-0x23, %eax
jae 0x54b5
xorl %ebp, %ebp
jmp 0x5581
movl %ecx, %r14d
movq %rdx, %rbx
movq (%rdi), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%r15)
movq 0x18(%rdi), %rax
movq %rax, 0x18(%r15)
movl %esi, %eax
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %rax, 0x18(%r12)
decl %r14d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incl %r13d
cmpl %r14d, %r13d
setbe %bpl
ja 0x5581
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x20(%rsp), %rcx
callq 0x4b96
movq 0x38(%rsp), %rax
leaq 0x1ce6(%rip), %rcx      # 0x7210
movb (%rax,%rcx), %cl
movl %r13d, %eax
movb %cl, (%rbx,%rax)
cmpq $0x0, 0x18(%rsp)
jne 0x54ff
cmpq $0x0, 0x10(%rsp)
jne 0x54ff
cmpq $0x0, 0x8(%rsp)
jne 0x54ff
cmpq $0x0, (%rsp)
jne 0x54ff
leal 0x1(%r13), %ecx
movb $0x0, (%rbx,%rcx)
testl %r13d, %r13d
je 0x5581
decq %rax
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb 0x1(%rbx,%rax), %sil
movb %sil, (%rbx,%rcx)
movb %dl, 0x1(%rbx,%rax)
incq %rcx
movl %eax, %edx
decq %rax
cmpq %rdx, %rcx
jb 0x5564
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: create
Stack create(int initSize){
    Stack stack;
    if(initSize<MIN_STACK_SIZE){
        fatal("stack size is too small");
    }
    stack=(Stack)malloc(sizeof(struct STACK));
    if(stack==NULL){
        fatal("stack malloc failed.");
    }
    stack->data=malloc(sizeof(int)*initSize);
    stack->size=initSize;
    clear(stack);
    return stack;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jle 0x11ee
movl %edi, %ebx
movl $0x10, %edi
callq 0x1080
testq %rax, %rax
je 0x11f7
movq %rax, %r14
movl %ebx, %edi
shlq $0x2, %rdi
callq 0x1080
movq %rax, 0x8(%r14)
movl %ebx, (%r14)
movl $0xffffffff, 0x4(%r14)  # imm = 0xFFFFFFFF
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xe0f(%rip), %rdi       # 0x2004
jmp 0x11fe
leaq 0xe1e(%rip), %rdi       # 0x201c
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: push
void push(int value, Stack s){
    assert(s!=NULL);
    if(isFull(s)){
        fatal("stack is full");
    }
    //s->data[++s->top]=value;
    ++s->top;
    s->data[s->top]=value;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x12e7
movslq 0x4(%rsi), %rax
movl (%rsi), %ecx
decl %ecx
cmpl %ecx, %eax
je 0x1306
leaq 0x1(%rax), %rcx
movl %ecx, 0x4(%rsi)
movq 0x8(%rsi), %rcx
movl %edi, 0x4(%rcx,%rax,4)
popq %rax
retq
leaq 0xd43(%rip), %rdi       # 0x2031
leaq 0xd44(%rip), %rsi       # 0x2039
leaq 0xd7f(%rip), %rcx       # 0x207b
movl $0x2d, %edx
callq 0x1070
leaq 0xd84(%rip), %rdi       # 0x2091
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: pop
void pop(Stack s){
    assert(s!=NULL);
    if(isEmpty(s)){
        fatal("stack is empty.");
    }
    s->top--;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1333
movl 0x4(%rdi), %eax
cmpl $-0x1, %eax
je 0x1352
decl %eax
movl %eax, 0x4(%rdi)
popq %rax
retq
leaq 0xcf7(%rip), %rdi       # 0x2031
leaq 0xcf8(%rip), %rsi       # 0x2039
leaq 0xd57(%rip), %rcx       # 0x209f
movl $0x36, %edx
callq 0x1070
leaq 0xdc4(%rip), %rdi       # 0x211d
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/mcxiaoke[P]dsaac/ch3/stack_array/stack2.c
// Function: top
int top(Stack s){
    assert(s!=NULL);
    if(isEmpty(s)){
        fatal("stack is empty.");
    }
    return s->data[s->top];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1383
movslq 0x4(%rdi), %rax
cmpq $-0x1, %rax
je 0x13a2
movq 0x8(%rdi), %rcx
movl (%rcx,%rax,4), %eax
popq %rcx
retq
leaq 0xca7(%rip), %rdi       # 0x2031
leaq 0xca8(%rip), %rsi       # 0x2039
leaq 0xd17(%rip), %rcx       # 0x20af
movl $0x3d, %edx
callq 0x1070
leaq 0xd74(%rip), %rdi       # 0x211d
xorl %eax, %eax
callq 0x1060
movl $0x1, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1478
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x1467
testl %r14d, %r14d
js 0x1458
leaq 0xcae(%rip), %r15       # 0x20e5
movq 0x8(%rbx), %rax
movl (%rax,%r14,4), %edx
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
leaq -0x1(%r14), %rax
testq %r14, %r14
movq %rax, %r14
jg 0x1437
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
leaq 0xcaf(%rip), %rdi       # 0x211d
popq %rbx
popq %r14
popq %r15
jmp 0x1050
leaq 0xbb2(%rip), %rdi       # 0x2031
leaq 0xbb3(%rip), %rsi       # 0x2039
leaq 0xc46(%rip), %rcx       # 0x20d3
movl $0x4b, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl $0xa, %ebp
movl $0xa, %edi
callq 0x11ac
movq %rax, %rbx
callq 0x10a0
movslq %eax, %rdi
imulq $0x51eb851f, %rdi, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %edi
movq %rbx, %rsi
callq 0x12c4
decl %ebp
jne 0x14ac
movl (%rbx), %esi
leaq 0xc0d(%rip), %rdi       # 0x20ef
xorl %eax, %eax
callq 0x1060
movl 0x4(%rbx), %esi
leaq 0xc0c(%rip), %rdi       # 0x20ff
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1410
movq %rbx, %rdi
callq 0x131e
movq %rbx, %rdi
callq 0x131e
movq %rbx, %rdi
callq 0x1410
movq %rbx, %rdi
callq 0x13ba
leaq 0xbe5(%rip), %rdi       # 0x210e
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x1410
movl $0xffffffff, 0x4(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x1410
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x11a0
movl $0x6, (%rax)
movq $0x20, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2, %edi
callq 0x11a0
movq %rax, %r14
movw $0x28, (%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2209
cmpq $0x0, 0x18(%rdi)
je 0x21e6
movq 0x10(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0x2209
xorl %r13d, %r13d
leaq 0x3e79(%rip), %r15      # 0x600c
movq 0x20(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x36f0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %r12, %rdi
callq 0x1030
movq 0x10(%rbx), %rax
movq 0x18(%rax), %rax
decq %rax
cmpq %rax, %r13
je 0x21d7
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fec
movq %rax, %r14
incq %r13
movq 0x10(%rbx), %rax
cmpq %r13, 0x18(%rax)
ja 0x2193
jmp 0x2209
testq %rdi, %rdi
je 0x2209
callq 0x36f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %r15, %rdi
callq 0x1030
leaq 0x3dfa(%rip), %rsi      # 0x600a
movq %r14, %rdi
callq 0x1fec
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x36f0
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
leaq 0x4171(%rip), %rsi      # 0x63b5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fec
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10, %edi
callq 0x11a0
movq %rax, %r14
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1150
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x3c38
cmpq $0x0, 0x18(%rbx)
je 0x24a6
movq %rbx, %rdi
callq 0x3c38
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2aab
movq %rax, %r12
jmp 0x24aa
movq 0x18(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x20ac
testl %eax, %eax
je 0x24ef
cmpq $0x0, 0x18(%rbx)
je 0x24ef
movq %rbx, %rdi
callq 0x3c38
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2aab
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x20e8
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
jmp 0x24b0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x3c38
cmpq $0x0, 0x18(%rbx)
je 0x2539
movq %rbx, %rdi
callq 0x3c38
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2aab
movq %rax, %r12
jmp 0x253d
movq 0x20(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x20b6
testl %eax, %eax
je 0x2582
cmpq $0x0, 0x18(%rbx)
je 0x2582
movq %rbx, %rdi
callq 0x3c38
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2aab
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x20fe
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
jmp 0x2543
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
cmpq $0x3, 0x18(%rdx)
jne 0x2609
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %rdi
callq 0x3c38
movq %r15, %rdi
callq 0x3c38
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2aab
movq %r14, %rdi
movq %rax, %rsi
callq 0x20ac
testl %eax, %eax
je 0x25e6
movq %r15, %rdi
callq 0x3c38
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x25ff
cmpq $0x2, 0x18(%r15)
jb 0x25f7
movq 0x20(%r15), %rax
movq 0x8(%rax), %rdx
jmp 0x25f9
xorl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2aab
leaq 0x3b66(%rip), %rsi      # 0x6176
movq %r15, %rdi
callq 0x1220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpq $0x1, 0x18(%rdx)
jbe 0x268b
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdi
callq 0x3c38
movq %rbx, %rdi
callq 0x3c38
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2aab
movq %r15, %rdi
movq %rax, %rsi
callq 0x20ac
testl %eax, %eax
je 0x269a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2db7
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c73
movq %rax, %r14
movq %rbx, %rdi
callq 0x3920
movq %r14, %rax
jmp 0x269c
leaq 0x3afd(%rip), %rsi      # 0x618f
movq %rbx, %rdi
callq 0x1220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x0, 0x7a65(%rip)      # 0xa120
jne 0x26d3
leaq 0x3aef(%rip), %rsi      # 0x61b3
movq %r15, %rdi
callq 0x5a24
movq %rax, 0x7a4d(%rip)      # 0xa120
movq %r14, %rdi
callq 0x3c38
cmpq $0x0, 0x18(%r14)
je 0x276c
movq 0x20(%r14), %rax
movq (%rax), %rsi
movl $0x5, %edi
callq 0x36e8
testl %eax, %eax
je 0x275d
movq %r14, %rdi
callq 0x3c38
movq %rax, %r12
movq %rax, %rdi
callq 0x3c38
cmpq 0x7a0b(%rip), %rax      # 0xa120
je 0x2734
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2aab
movq %r15, %rdi
movq %rax, %rsi
callq 0x20ac
testl %eax, %eax
je 0x26db
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2db7
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c73
movq %rax, %r14
movq %rbx, %rdi
callq 0x3920
movq %r14, %rax
jmp 0x276e
leaq 0x3a54(%rip), %rsi      # 0x61b8
movq %r14, %rdi
callq 0x1220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
cmpq $0x3, 0x18(%rdx)
jne 0x27d8
movq %rsi, %rbx
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36e8
testl %eax, %eax
je 0x27d8
movq %r14, %rdi
callq 0x3c38
movq %r14, %rdi
callq 0x3c38
movq %rax, %r15
movq %r14, %rdi
callq 0x3c38
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2314
testq %rax, %rax
je 0x27e9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3a13(%rip), %rsi      # 0x61f2
movq %r14, %rdi
callq 0x1220
jmp 0x27d0
movq %r15, %rdi
callq 0x1285
jmp 0x27d0
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/eval.c
// Function: define
static LakeVal *_define(LakeCtx *ctx, Env *env, LakeList *expr)
{
    /* TODO: make these more robust, check all expected params */

    /* (define x 42) */
    if (LIST_N(expr) == 3 && lake_is_type(TYPE_SYM, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "define" symbol */
        LakeSym *var = SYM(list_shift(expr));
        LakeVal *form = list_shift(expr);
        env_define(env, var, eval(ctx, env, form));
    }

    /* (define (inc x) (+ 1 x)) */
    else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_LIST, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "define" symbol */
        LakeList *params = LIST(list_shift(expr));
        LakeSym *var = SYM(list_shift(params));
        LakeList *body = expr;
        env_define(env, var, VAL(fn_make(params, NULL, body, env)));
    }

    /* (define (print format . args) (...)) */
    else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_DLIST, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "define" symbol */
        LakeDottedList *def = DLIST(list_shift(expr));
        LakeList *params = dlist_head(def);
        LakeSym *varargs = SYM(dlist_tail(def));
        LakeSym *var = SYM(list_shift(params));
        LakeList *body = expr;
        env_define(env, var, VAL(fn_make(params, varargs, body, env)));
    }

    else
    {
        invalid_special_form(expr, "define requires at least 2 parameters");
    }

    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x3, 0x18(%rdx)
jne 0x284d
movq %rdi, %r15
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36e8
testl %eax, %eax
je 0x284d
movq %r14, %rdi
callq 0x3c38
movq %r14, %rdi
callq 0x3c38
movq %rax, %r12
movq %r14, %rdi
callq 0x3c38
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2aab
jmp 0x2898
cmpq $0x3, 0x18(%r14)
jb 0x28a0
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x5, %edi
callq 0x36e8
testl %eax, %eax
je 0x28a0
movq %r14, %rdi
callq 0x3c38
movq %r14, %rdi
callq 0x3c38
movq %rax, %r15
movq %rax, %rdi
callq 0x3c38
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e40
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x2908
cmpq $0x3, 0x18(%r14)
jb 0x291c
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x6, %edi
callq 0x36e8
testl %eax, %eax
je 0x291c
movq %r14, %rdi
callq 0x3c38
movq %r14, %rdi
callq 0x3c38
movq %rax, %r15
movq %rax, %rdi
callq 0x213e
movq %rax, %r12
movq %r15, %rdi
callq 0x2143
movq %rax, %r15
movq %r12, %rdi
callq 0x3c38
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e40
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x22fe
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x38f2(%rip), %rsi      # 0x6215
movq %r14, %rdi
callq 0x1220
jmp 0x2910
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/eval.c
// Function: lambda
static LakeVal *_lambda(LakeCtx *ctx, Env *env, LakeList *expr)
{
    /* (lambda (a b c) ...) */
    if (LIST_N(expr) >= 3 && lake_is_type(TYPE_LIST, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "lambda" symbol */
        LakeList *params = LIST(list_shift(expr));
        LakeList *body = expr;
        return VAL(fn_make(params, NULL, body, env));
    }
    else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_DLIST, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "lambda" symbol */
        LakeDottedList *def = DLIST(list_shift(expr));
        LakeList *params = dlist_head(def);
        LakeSym *varargs = SYM(dlist_tail(def));
        LakeList *body = expr;
        return VAL(fn_make(params, varargs, body, env));
    }
    else if (LIST_N(expr) >= 3 && lake_is_type(TYPE_SYM, LIST_VAL(expr, 1)))
    {
        list_shift(expr); /* drop the "lambda" symbol */
        LakeSym *varargs = SYM(list_shift(expr));
        LakeList *body = expr;
        return VAL(fn_make(list_make(), varargs, body, env));
    }
    else
    {
        invalid_special_form(expr, "lambda requires at least 2 parameters");
        return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x3, 0x18(%rdx)
jb 0x2972
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x5, %edi
callq 0x36e8
testl %eax, %eax
je 0x2972
movq %rbx, %rdi
callq 0x3c38
movq %rbx, %rdi
callq 0x3c38
movq %rax, %rdi
xorl %esi, %esi
jmp 0x29f8
cmpq $0x3, 0x18(%rbx)
jb 0x29bd
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x6, %edi
callq 0x36e8
testl %eax, %eax
je 0x29bd
movq %rbx, %rdi
callq 0x3c38
movq %rbx, %rdi
callq 0x3c38
movq %rax, %r15
movq %rax, %rdi
callq 0x213e
movq %rax, %r12
movq %r15, %rdi
callq 0x2143
movq %r12, %rdi
movq %rax, %rsi
jmp 0x29f8
cmpq $0x3, 0x18(%rbx)
jb 0x2a0e
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36e8
testl %eax, %eax
je 0x2a0e
movq %rbx, %rdi
callq 0x3c38
movq %rbx, %rdi
callq 0x3c38
movq %rax, %r15
callq 0x392a
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e40
leaq 0x3826(%rip), %rsi      # 0x623b
movq %rbx, %rdi
callq 0x1220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdx), %rdi
callq 0x396e
movq %rax, %r12
cmpq $0x0, 0x18(%rbx)
je 0x2e06
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2aab
movq %r12, %rdi
movq %rax, %rsi
callq 0x3ac7
incq %r13
cmpq %r13, 0x18(%rbx)
ja 0x2ddf
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
callq 0x2db7
movq %rax, %rbx
movq %rax, %rdi
callq 0x3c73
movq %rax, %r14
movq %rbx, %rdi
callq 0x3920
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x30, %edi
callq 0x11a0
movl $0x8, (%rax)
movq $0x30, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/fn.c
// Function: fn_repr
char *fn_repr(LakeFn *fn)
{
    char *s = malloc(8);
    s[0] = '\0';
    s = lake_str_append(s, "(lambda ");
    char *s2;
    if (LIST_N(fn->params) && fn->varargs)
    {
        LakeDottedList *params = dlist_make(fn->params, VAL(fn->varargs));
        s2 = dlist_repr(params);
        s = lake_str_append(s, s2);
        free(s2);
    }
    else if (fn->varargs)
    {
        s2 = lake_repr(fn->varargs);
        s = lake_str_append(s, s2);
        free(s2);
    }
    else
    {
        s2 = lake_repr(fn->params);
        s = lake_str_append(s, s2);
        free(s2);
    }
    s = lake_str_append(s, " ");
    int i;
    for (i = 0; i < LIST_N(fn->body); ++i)
    {
        s2 = lake_repr(LIST_VAL(fn->body, i));
        s = lake_str_append(s, s2);
        free(s2);
        if (i != LIST_N(fn->body) - 1) s = lake_str_append(s, " ");
    }
    return lake_str_append(s, ")");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0x11a0
movb $0x0, (%rax)
leaq 0x33d7(%rip), %rsi      # 0x627f
movq %rax, %rdi
callq 0x1fec
movq %rax, %r14
movq 0x10(%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2ed6
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x2ed6
callq 0x210c
movq %rax, %rdi
callq 0x2148
jmp 0x2ee7
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x2ee2
movq %rax, %rdi
callq 0x36f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %r15, %rdi
callq 0x1030
leaq 0x3105(%rip), %rsi      # 0x600c
movq %r14, %rdi
callq 0x1fec
movq %rax, %r14
movq 0x20(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f78
xorl %r13d, %r13d
leaq 0x30e5(%rip), %r15      # 0x600c
movq 0x20(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x36f0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %r12, %rdi
callq 0x1030
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
decq %rax
cmpq %rax, %r13
je 0x2f6b
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fec
movq %rax, %r14
incq %r13
movq 0x20(%rbx), %rax
cmpq %r13, 0x18(%rax)
ja 0x2f27
leaq 0x3436(%rip), %rsi      # 0x63b5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fec
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x15, %edi
callq 0x11a0
movq %rax, %r14
movl 0x10(%rbx), %ecx
leaq 0x2be4(%rip), %rdx      # 0x6298
movl $0x14, %esi
movq %rax, %rdi
xorl %eax, %eax
callq 0x10d0
movq %r14, %rdi
callq 0x597e
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3722
movl (%rdi), %edx
leal -0x1(%rdx), %eax
cmpl $0x8, %eax
ja 0x37b4
leaq 0x2b8d(%rip), %rcx      # 0x629c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
popq %r14
popq %r15
jmp 0x5ad2
leaq 0x2bdf(%rip), %rdi      # 0x6308
popq %rbx
popq %r14
popq %r15
jmp 0x11f0
popq %rbx
popq %r14
popq %r15
jmp 0x3d2a
popq %rbx
popq %r14
popq %r15
jmp 0x365e
movq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x10b0
leaq 0x3(%rax), %r14
movq %r14, %rdi
callq 0x11a0
movq %rax, %r15
leaq 0x2ba6(%rip), %rdx      # 0x630f
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
popq %rbx
popq %r14
popq %r15
jmp 0x2e88
popq %rbx
popq %r14
popq %r15
jmp 0x20cd
popq %rbx
popq %r14
popq %r15
jmp 0x2148
popq %rbx
popq %r14
popq %r15
jmp 0x45b4
popq %rbx
popq %r14
popq %r15
jmp 0x2075
movq 0x683d(%rip), %rax      # 0x9ff8
movq (%rax), %rax
movq 0x8(%rdi), %rcx
leaq 0x2b4b(%rip), %rsi      # 0x6314
movq %rax, %rdi
xorl %eax, %eax
callq 0x1170
leaq 0x2b6d(%rip), %rdi      # 0x6347
jmp 0x3729
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x380f
cmpl $0x3, %eax
jne 0x3822
cmpl $0x3, (%rsi)
jne 0x380a
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
jmp 0x3825
cmpl $0x5, %eax
jne 0x3822
cmpq $0x0, 0x18(%rdi)
jne 0x3822
cmpl $0x5, (%rsi)
jne 0x3822
cmpq $0x0, 0x18(%rsi)
je 0x382c
cmpq %rsi, %rdi
sete %al
movzbl %al, %eax
retq
movb $0x1, %al
jmp 0x3828
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl (%rdi), %eax
xorl %ebx, %ebx
cmpl (%rsi), %eax
jne 0x3858
decl %eax
cmpl $0x8, %eax
ja 0x387e
leaq 0x2a79(%rip), %rcx      # 0x62c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %ebx, %ebx
cmpq %rsi, %rdi
sete %bl
movl %ebx, %eax
popq %rbx
retq
popq %rbx
jmp 0x2255
popq %rbx
jmp 0x59f0
popq %rbx
jmp 0x3c90
popq %rbx
jmp 0x2086
movl 0x10(%rdi), %eax
xorl %ebx, %ebx
cmpl 0x10(%rsi), %eax
jmp 0x3855
callq 0x15af
jmp 0x3858
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl $0x28, %edi
callq 0x11a0
movq %rax, %rbx
xorl %edi, %edi
callq 0x2298
movq %rax, (%rbx)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1150
movq %rax, 0x8(%rbx)
movl $0x1, %edi
movl $0x28, %esi
callq 0x1150
movq %rax, 0x10(%rbx)
movl $0x18, %r14d
movl $0x18, %edi
callq 0x11a0
movl $0x2, %ebp
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movl $0x1, 0x10(%rax)
movq %rax, 0x18(%rbx)
movl $0x18, %edi
callq 0x11a0
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x4604
movq %rbx, %rdi
callq 0x2378
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/list.c
// Function: list_make
static LakeList *list_alloc(void)
{
    LakeList *list = malloc(sizeof(LakeList));
    VAL(list)->type = TYPE_LIST;
    VAL(list)->size = sizeof(LakeList);
    return list;
}

// Assembly:
pushq %rbx
movl $0x28, %edi
callq 0x11a0
movq %rax, %rbx
movl $0x5, (%rax)
movq $0x28, 0x8(%rax)
movq $0x2, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x10, %edi
callq 0x11a0
movq %rax, 0x20(%rbx)
movw $0x0, (%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0x11a0
movq %rax, %r14
movl $0x5, (%rax)
movq $0x28, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
shlq $0x3, %rbx
movq %rbx, %rdi
callq 0x11a0
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x5, %edi
callq 0x36e8
testl %eax, %eax
je 0x39e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a50
movq %rbx, %r14
jmp 0x3a47
movl $0x28, %edi
callq 0x11a0
movq %rax, %r14
movl $0x5, (%rax)
movq $0x28, 0x8(%rax)
movq $0x2, 0x10(%rax)
movq $0x0, 0x18(%rax)
movl $0x10, %edi
callq 0x11a0
movq %rax, 0x20(%r14)
movq $0x1, 0x18(%r14)
movq %r15, (%rax)
cmpq $0x1, 0x10(%r14)
ja 0x3a33
movq %r14, %rdi
callq 0x3c0b
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%r14)
movq %rbx, (%rcx,%rax,8)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x3a99
cmpq %rax, %rcx
jb 0x3a74
movq %r14, %rdi
callq 0x3c0b
movq 0x18(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%r14)
movq 0x20(%r14), %rcx
movq -0x8(%rcx,%rax,8), %rdx
movq %rdx, (%rcx,%rax,8)
addq $-0x1, %rax
jb 0x3a80
movq 0x20(%r14), %rax
jmp 0x3aba
cmpq %rax, %rcx
jb 0x3aa6
movq %r14, %rdi
callq 0x3c0b
movq 0x18(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%r14)
shlq $0x3, %rax
addq 0x20(%r14), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
jb 0x3ae3
movq %r14, %rdi
callq 0x3c0b
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%r14)
movq %rbx, (%rcx,%rax,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %edi
callq 0x11a0
movq %rax, %r15
movl $0x5, (%rax)
movq $0x28, 0x8(%rax)
movq %r14, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq (,%r14,8), %r12
movq %r12, %rdi
callq 0x11a0
movq %rax, 0x20(%r15)
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1190
movq %r14, 0x18(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x3c70
movq 0x20(%rdi), %rax
movq (%rax), %rax
cmpq $0x1, %rcx
je 0x3c68
movl $0x1, %edx
movq 0x20(%rdi), %rsi
movq (%rsi,%rdx,8), %r8
movq %r8, -0x8(%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x3c53
decq %rcx
movq %rcx, 0x18(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x3c8d
movq 0x20(%rdi), %rax
movq -0x8(%rax,%rcx,8), %rax
decq %rcx
movq %rcx, 0x18(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/list.c
// Function: list_equal
bool list_equal(LakeList *a, LakeList *b)
{
    if (a == b) return TRUE;
    size_t n = LIST_N(a);
    if (n != LIST_N(b)) return FALSE;
    size_t i;
    for (i = 0; i < n; ++i)
    {
        if (!lake_equal(LIST_VAL(a, i), LIST_VAL(b, i))) return FALSE;
    }
    return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x1, %ebx
cmpq %rsi, %rdi
je 0x3cf4
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %r12
cmpq 0x18(%rsi), %r12
jne 0x3cf2
testq %r12, %r12
je 0x3cf4
xorl %r13d, %r13d
cmpq 0x18(%r15), %r13
jae 0x3ccb
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %rdi
jmp 0x3ccd
xorl %edi, %edi
cmpq 0x18(%r14), %r13
jae 0x3cdd
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rsi
jmp 0x3cdf
xorl %esi, %esi
callq 0x3830
testl %eax, %eax
je 0x3cf2
incq %r13
cmpq %r13, %r12
jne 0x3cbb
jmp 0x3cf4
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/list.c
// Function: list_to_str
LakeStr *list_to_str(LakeList *list)
{
    char *s = list_repr(list);
    LakeStr *str = lake_str_from_c(s);
    free(s);
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3d2a
movq %rax, %rbx
movq %rax, %rdi
callq 0x597e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/list.c
// Function: list_repr
char *list_repr(LakeList *list)
{
    char *s = malloc(2);
    s[0] = '(';
    s[1] = '\0';
    int i;
    char *s2;
    LakeVal *val;
    for (i = 0; i < LIST_N(list); ++i)
    {
        val = LIST_VAL(list, i);
        if (val == VAL(list))
        {
            s2 = strdup("[Circular]");
        }
        else
        {
            s2 = lake_repr(val);
        }
        s = lake_str_append(s, s2);
        free(s2);
        if (i != LIST_N(list) - 1) s = lake_str_append(s, " ");
    }
    return lake_str_append(s, ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %edi
callq 0x11a0
movq %rax, %r14
movw $0x28, (%rax)
cmpq $0x0, 0x18(%rbx)
je 0x3db9
xorl %ebp, %ebp
leaq 0x265d(%rip), %r15      # 0x63b7
leaq 0x22ab(%rip), %r12      # 0x600c
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %rdi
cmpq %rbx, %rdi
je 0x3d75
callq 0x36f0
jmp 0x3d7d
movq %r15, %rdi
callq 0x11f0
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fec
movq %rax, %r14
movq %r13, %rdi
callq 0x1030
movq 0x18(%rbx), %rax
decq %rax
cmpq %rax, %rbp
je 0x3db0
movq %r14, %rdi
movq %r12, %rsi
callq 0x1fec
movq %rax, %r14
incq %rbp
cmpq %rbp, 0x18(%rbx)
ja 0x3d61
leaq 0x25f5(%rip), %rsi      # 0x63b5
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fec
nop
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/parse.c
// Function: parse_expr
LakeVal *parse_expr(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeVal *result = _parse_expr(&ctx);
    warn_trailing(&ctx);
    return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
movq %rdx, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq %rdi, 0x20(%rbx)
movq %rbx, %rdi
callq 0x3e12
movq %rax, %r14
movq %rbx, %rdi
callq 0x3fbf
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/parse.c
// Function: warn_trailing
static void warn_trailing(Ctx *ctx)
{
    maybe_spaces(ctx);
    /* don't warn about trailing comments */
    if (ctx->i < ctx->n && peek(ctx) != ';')
    {
        char *trailing = ctx->s + ctx->i;
        fprintf(stderr, "warning: ignoring %d trailing chars: %s\n",
                (int)(ctx->n - ctx->i), trailing);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4110
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
cmpq %rax, %rdx
jbe 0x3fde
movq (%rbx), %rcx
cmpb $0x3b, (%rcx,%rax)
jne 0x3fe0
popq %rbx
retq
movq (%rbx), %rcx
addq %rax, %rcx
movq 0x600b(%rip), %rsi      # 0x9ff8
movq (%rsi), %rdi
subl %eax, %edx
leaq 0x23e4(%rip), %rsi      # 0x63dd
xorl %eax, %eax
popq %rbx
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/parse.c
// Function: parse_exprs
LakeList *parse_exprs(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeList *results = list_make();
    LakeVal *result;
    while (ctx.i < ctx.n)
    {
        result = _parse_expr(&ctx);
        if (result && result != VAL(PARSE_ERR))
        {
            list_append(results, result);
        }
        else
        {
            list_free(results);
            return NULL;
        }
    }
    warn_trailing(&ctx);
    return results;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
callq 0x392a
movq %rax, %rbx
testq %r14, %r14
je 0x405b
movq %rsp, %r14
movq %r14, %rdi
callq 0x3e12
cmpq $-0x2, %rax
je 0x4065
testq %rax, %rax
je 0x4065
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ac7
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x4031
movq %rsp, %rdi
callq 0x3fbf
jmp 0x406f
movq %rbx, %rdi
callq 0x3920
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/samsonjs[P]lake/src/parse.c
// Function: parse_naked_list
LakeList *parse_naked_list(LakeCtx *lake_ctx, char *s, size_t n)
{
    Ctx ctx = {s, n, 0, 0, lake_ctx};
    LakeList *list = list_make();
    char c;
    maybe_spaces(&ctx);
    while ((c = peek(&ctx)) != PARSE_EOF)
    {
        LakeVal *val = _parse_expr(&ctx);
        if (val == VAL(PARSE_ERR))
        {
            list_free(list);
            ctx.i = ctx.n;
            return NULL;
        }
        list_append(list, val);
    }
    warn_trailing(&ctx);
    return list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rdi, 0x20(%r14)
callq 0x392a
movq %rax, %rbx
movq %r14, %rdi
callq 0x4110
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x40f9
movq 0x8(%rsp), %rcx
cmpb $-0x1, (%rcx,%rax)
je 0x40f9
movq %r14, %rdi
callq 0x3e12
movq %rax, %r15
movq %rbx, %rdi
cmpq $-0x2, %rax
je 0x40e0
movq %r15, %rsi
callq 0x3ac7
jmp 0x40ef
callq 0x3920
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $-0x2, %r15
jne 0x40ab
xorl %ebx, %ebx
jmp 0x4103
leaq 0x8(%rsp), %rdi
callq 0x3fbf
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq