LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x520d
xorl %ebp, %ebp
jmp 0x52ce
movl %ecx, %r14d
movq %rdx, %rbx
movups (%rdi), %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movups 0x10(%rdi), %xmm0
movaps %xmm0, 0x10(%r15)
movl %esi, %eax
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %rax, 0x18(%r12)
decl %r14d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
incl %r13d
cmpl %r14d, %r13d
setbe %bpl
ja 0x52ce
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x20(%rsp), %rcx
callq 0x4a11
movq 0x38(%rsp), %rax
leaq 0x1f99(%rip), %rcx      # 0x7210
movb (%rax,%rcx), %cl
movl %r13d, %eax
movb %cl, (%rbx,%rax)
cmpq $0x0, 0x18(%rsp)
jne 0x524c
cmpq $0x0, 0x10(%rsp)
jne 0x524c
cmpq $0x0, 0x8(%rsp)
jne 0x524c
cmpq $0x0, (%rsp)
jne 0x524c
leal 0x1(%r13), %ecx
movb $0x0, (%rbx,%rcx)
testl %r13d, %r13d
je 0x52ce
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 0x52b1
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_O3/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 0x1472
movq %rdi, %rbx
movl 0x4(%rdi), %r14d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x1461
testl %r14d, %r14d
js 0x1452
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
addq $-0x1, %r14
jb 0x1437
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
leaq 0xcb5(%rip), %rdi       # 0x211d
popq %rbx
popq %r14
popq %r15
jmp 0x1050
leaq 0xbb8(%rip), %rdi       # 0x2031
leaq 0xbb9(%rip), %rsi       # 0x2039
leaq 0xc4c(%rip), %rcx       # 0x20d3
movl $0x4b, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x14a6
movl (%rbx), %esi
leaq 0xc13(%rip), %rdi       # 0x20ef
xorl %eax, %eax
callq 0x1060
movl 0x4(%rbx), %esi
leaq 0xc12(%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 0xbeb(%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_O3/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 0x21d9
cmpq $0x0, 0x18(%rdi)
je 0x21bb
xorl %r13d, %r13d
leaq 0x3ea8(%rip), %r15      # 0x600c
movq 0x20(%rdi), %rax
movq (%rax,%r13,8), %rdi
callq 0x36ac
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %r12, %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
movq 0x18(%rdi), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r13
je 0x21b1
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fcc
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq 0x18(%rdi), %rax
incq %r13
cmpq %r13, %rax
ja 0x2164
jmp 0x21d9
callq 0x36ac
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %r15, %rdi
callq 0x1030
leaq 0x3e2a(%rip), %rsi      # 0x600a
movq %r14, %rdi
callq 0x1fcc
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x36ac
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
leaq 0x41a1(%rip), %rsi      # 0x63b5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fcc
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rbx
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %r14
movq %rax, %rdi
movq %rcx, %rsi
callq 0x37e7
testl %eax, %eax
je 0x225e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37e7
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x2260
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x339d
testq %rax, %rax
jne 0x2310
movq (%r15), %r15
testq %r15, %r15
jne 0x22f2
xorl %ebx, %ebx
jmp 0x2320
movq 0x8(%r15), %rdi
movq 0x18(%r14), %rsi
movq %rbx, %rdx
callq 0x2f60
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x3ccd(%rip), %rsi      # 0x6034
leaq 0xbe(%rip), %rdx        # 0x242c
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3cbc(%rip), %rsi      # 0x603a
leaq 0xc6(%rip), %rdx        # 0x244b
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x428a(%rip), %rsi      # 0x661f
leaq 0x142(%rip), %rdx       # 0x24de
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c92(%rip), %rsi      # 0x603e
leaq 0x1be(%rip), %rdx       # 0x2571
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c7e(%rip), %rsi      # 0x6041
leaq 0x236(%rip), %rdx       # 0x2600
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c6c(%rip), %rsi      # 0x6046
leaq 0x2a1(%rip), %rdx       # 0x2682
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c5a(%rip), %rsi      # 0x604b
leaq 0x362(%rip), %rdx       # 0x275a
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c48(%rip), %rsi      # 0x6050
leaq 0x3c4(%rip), %rdx       # 0x27d3
callq 0x2f60
movq 0x10(%rbx), %rdi
leaq 0x3c38(%rip), %rsi      # 0x6057
leaq 0x4f1(%rip), %rdx       # 0x2917
popq %rbx
jmp 0x2f60
// File: /workspace/github_c_makefile_star2_O3/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 0x3bc4
cmpq $0x0, 0x18(%rbx)
je 0x2486
movq %rbx, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %rax, %r12
jmp 0x248a
movq 0x18(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x208c
testl %eax, %eax
je 0x24cf
cmpq $0x0, 0x18(%rbx)
je 0x24cf
movq %rbx, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x20c8
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
jmp 0x2490
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3bc4
cmpq $0x0, 0x18(%rbx)
je 0x2519
movq %rbx, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %rax, %r12
jmp 0x251d
movq 0x20(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2096
testl %eax, %eax
je 0x2562
cmpq $0x0, 0x18(%rbx)
je 0x2562
movq %rbx, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x20de
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
jmp 0x2523
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25e9
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %rdi
callq 0x3bc4
movq %r15, %rdi
callq 0x3bc4
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %r14, %rdi
movq %rax, %rsi
callq 0x208c
testl %eax, %eax
je 0x25c6
movq %r15, %rdi
callq 0x3bc4
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
jmp 0x25df
cmpq $0x2, 0x18(%r15)
jb 0x25d7
movq 0x20(%r15), %rax
movq 0x8(%rax), %rdx
jmp 0x25d9
xorl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2a9d
leaq 0x3b86(%rip), %rsi      # 0x6176
movq %r15, %rdi
callq 0x1220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x266b
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdi
callq 0x3bc4
movq %rbx, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %r15, %rdi
movq %rax, %rsi
callq 0x208c
testl %eax, %eax
je 0x267a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2d89
movq %rax, %rbx
movq %rax, %rdi
callq 0x3bff
movq %rax, %r14
movq %rbx, %rdi
callq 0x38d8
movq %r14, %rax
jmp 0x267c
leaq 0x3b1d(%rip), %rsi      # 0x618f
movq %rbx, %rdi
callq 0x1220
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x7a85(%rip)      # 0xa120
jne 0x26b3
leaq 0x3b0f(%rip), %rsi      # 0x61b3
movq %r15, %rdi
callq 0x58f0
movq %rax, 0x7a6d(%rip)      # 0xa120
movq %r14, %rdi
callq 0x3bc4
cmpq $0x0, 0x18(%r14)
je 0x274c
movq 0x20(%r14), %rax
movq (%rax), %rsi
movl $0x5, %edi
callq 0x36a4
testl %eax, %eax
je 0x273d
movq %r14, %rdi
callq 0x3bc4
movq %rax, %r12
movq %rax, %rdi
callq 0x3bc4
cmpq 0x7a2b(%rip), %rax      # 0xa120
je 0x2714
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a9d
movq %r15, %rdi
movq %rax, %rsi
callq 0x208c
testl %eax, %eax
je 0x26bb
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2d89
movq %rax, %rbx
movq %rax, %rdi
callq 0x3bff
movq %rax, %r14
movq %rbx, %rdi
callq 0x38d8
movq %r14, %rax
jmp 0x274e
leaq 0x3a74(%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_O3/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 0x27b8
movq %rsi, %rbx
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36a4
testl %eax, %eax
je 0x27b8
movq %r14, %rdi
callq 0x3bc4
movq %r14, %rdi
callq 0x3bc4
movq %rax, %r15
movq %r14, %rdi
callq 0x3bc4
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x22e4
testq %rax, %rax
je 0x27c9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3a33(%rip), %rsi      # 0x61f2
movq %r14, %rdi
callq 0x1220
jmp 0x27b0
movq %r15, %rdi
callq 0x1285
jmp 0x27b0
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x18(%rdx), %rax
cmpq $0x3, %rax
jne 0x2834
movq %rdi, %r15
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36a4
testl %eax, %eax
je 0x2830
movq %r14, %rdi
callq 0x3bc4
movq %r14, %rdi
callq 0x3bc4
movq %rax, %r12
movq %r14, %rdi
callq 0x3bc4
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a9d
jmp 0x2882
movq 0x18(%r14), %rax
cmpq $0x3, %rax
jb 0x2906
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x5, %edi
callq 0x36a4
testl %eax, %eax
je 0x288a
movq %r14, %rdi
callq 0x3bc4
movq %r14, %rdi
callq 0x3bc4
movq %rax, %r15
movq %rax, %rdi
callq 0x3bc4
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e10
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x28f2
cmpq $0x3, 0x18(%r14)
jb 0x2906
movq 0x20(%r14), %rax
movq 0x8(%rax), %rsi
movl $0x6, %edi
callq 0x36a4
testl %eax, %eax
je 0x2906
movq %r14, %rdi
callq 0x3bc4
movq %r14, %rdi
callq 0x3bc4
movq %rax, %r15
movq %rax, %rdi
callq 0x211e
movq %rax, %r12
movq %r15, %rdi
callq 0x2123
movq %rax, %r15
movq %r12, %rdi
callq 0x3bc4
movq %rax, %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2e10
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x22ce
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3908(%rip), %rsi      # 0x6215
movq %r14, %rdi
callq 0x1220
jmp 0x28fa
// File: /workspace/github_c_makefile_star2_O3/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
cmpq $0x3, 0x18(%rdx)
jb 0x2a00
movq %rsi, %r14
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x5, %edi
callq 0x36a4
testl %eax, %eax
je 0x2960
movq %rbx, %rdi
callq 0x3bc4
movq %rbx, %rdi
callq 0x3bc4
movq %rax, %rdi
xorl %esi, %esi
jmp 0x29ea
cmpq $0x3, 0x18(%rbx)
jb 0x2a00
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x6, %edi
callq 0x36a4
testl %eax, %eax
je 0x29af
movq %rbx, %rdi
callq 0x3bc4
movq %rbx, %rdi
callq 0x3bc4
movq %rax, %r15
movq %rax, %rdi
callq 0x211e
movq %rax, %r12
movq %r15, %rdi
callq 0x2123
movq %r12, %rdi
movq %rax, %rsi
jmp 0x29ea
cmpq $0x3, 0x18(%rbx)
jb 0x2a00
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edi
callq 0x36a4
testl %eax, %eax
je 0x2a00
movq %rbx, %rdi
callq 0x3bc4
movq %rbx, %rdi
callq 0x3bc4
movq %rax, %r15
callq 0x38e2
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e10
leaq 0x3834(%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_O3/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 0x3926
movq %rax, %r12
cmpq $0x0, 0x18(%rbx)
je 0x2dd8
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a9d
movq %r12, %rdi
movq %rax, %rsi
callq 0x3a63
incq %r13
cmpq %r13, 0x18(%rbx)
ja 0x2db1
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2d89
movq %rax, %rbx
movq %rax, %rdi
callq 0x3bff
movq %rax, %r14
movq %rbx, %rdi
callq 0x38d8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3407(%rip), %rsi      # 0x627f
movq %rax, %rdi
callq 0x1fcc
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rsi
cmpq $0x0, 0x18(%rdi)
je 0x2ea6
testq %rsi, %rsi
je 0x2eae
callq 0x20ec
movq %rax, %rdi
callq 0x2128
jmp 0x2eb3
testq %rsi, %rsi
je 0x2eae
movq %rsi, %rdi
callq 0x36ac
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %r15, %rdi
callq 0x1030
leaq 0x3139(%rip), %rsi      # 0x600c
movq %r14, %rdi
callq 0x1fcc
movq %rax, %r14
movq 0x20(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f48
xorl %r13d, %r13d
leaq 0x3119(%rip), %r15      # 0x600c
movq 0x20(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x36ac
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %r12, %rdi
callq 0x1030
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %r13
je 0x2f40
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fcc
movq %rax, %r14
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
incq %r13
cmpq %r13, %rcx
ja 0x2ef3
leaq 0x3466(%rip), %rsi      # 0x63b5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1fcc
// File: /workspace/github_c_makefile_star2_O3/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 0x2c28(%rip), %rdx      # 0x6298
movl $0x14, %esi
movq %rax, %rdi
xorl %eax, %eax
callq 0x10d0
movq %r14, %rdi
callq 0x584a
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_O3/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 0x36de
movl (%rdi), %edx
leal -0x1(%rdx), %eax
cmpl $0x8, %eax
ja 0x3770
leaq 0x2bd1(%rip), %rcx      # 0x629c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
popq %r14
popq %r15
jmp 0x599e
leaq 0x2c23(%rip), %rdi      # 0x6308
popq %rbx
popq %r14
popq %r15
jmp 0x11f0
popq %rbx
popq %r14
popq %r15
jmp 0x3cb6
popq %rbx
popq %r14
popq %r15
jmp 0x361a
movq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x10b0
leaq 0x3(%rax), %r14
movq %r14, %rdi
callq 0x11a0
movq %rax, %r15
leaq 0x2bea(%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 0x2e58
popq %rbx
popq %r14
popq %r15
jmp 0x20ad
popq %rbx
popq %r14
popq %r15
jmp 0x2128
popq %rbx
popq %r14
popq %r15
jmp 0x453c
popq %rbx
popq %r14
popq %r15
jmp 0x2055
movq 0x6881(%rip), %rax      # 0x9ff8
movq (%rax), %rax
movq 0x8(%rdi), %rcx
leaq 0x2b8f(%rip), %rsi      # 0x6314
movq %rax, %rdi
xorl %eax, %eax
callq 0x1170
leaq 0x2bb1(%rip), %rdi      # 0x6347
jmp 0x36e5
// File: /workspace/github_c_makefile_star2_O3/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 0x37c6
cmpl $0x3, %eax
jne 0x37d9
cmpl $0x3, (%rsi)
jne 0x37d9
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
jmp 0x37dc
cmpq $0x0, 0x18(%rdi)
jne 0x37d9
cmpl $0x5, (%rsi)
jne 0x37d9
cmpq $0x0, 0x18(%rsi)
je 0x37e3
cmpq %rsi, %rdi
sete %al
movzbl %al, %eax
retq
movb $0x1, %al
jmp 0x37df
// File: /workspace/github_c_makefile_star2_O3/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 0x380f
decl %eax
cmpl $0x8, %eax
ja 0x3835
leaq 0x2ac2(%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 0x2225
popq %rbx
jmp 0x58bc
popq %rbx
jmp 0x3c1c
popq %rbx
jmp 0x2066
movl 0x10(%rdi), %eax
xorl %ebx, %ebx
cmpl 0x10(%rsi), %eax
jmp 0x380c
callq 0x15af
jmp 0x380f
// File: /workspace/github_c_makefile_star2_O3/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 0x2268
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 0x458c
movq %rbx, %rdi
callq 0x2358
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x5, %edi
callq 0x36a4
testl %eax, %eax
je 0x3998
movq %rbx, %rdi
movq %r14, %rsi
callq 0x39e8
jmp 0x39d9
movl $0x28, %edi
callq 0x11a0
movq %rax, %r15
movl $0x5, (%rax)
movq $0x28, 0x8(%rax)
movl $0x2, %r12d
movq %r12, 0x10(%rax)
movl $0x10, %edi
callq 0x11a0
movq %rax, 0x20(%r15)
movq %r14, (%rax)
movq %r12, 0x18(%r15)
movq %rbx, 0x8(%rax)
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rcx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3a31
cmpq %rcx, %rax
jb 0x3a10
movq %r14, %rdi
callq 0x3b97
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 0x3a18
movq 0x20(%r14), %rax
jmp 0x3a56
testq %rcx, %rcx
je 0x3a3a
xorl %eax, %eax
jmp 0x3a46
movq %r14, %rdi
callq 0x3b97
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_O3/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 0x3a83
movq %r14, %rdi
callq 0x3b97
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_O3/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 0x3bfc
movq 0x20(%rdi), %rax
movq (%rax), %rax
cmpq $0x1, %rcx
je 0x3bf4
movl $0x1, %edx
movq 0x20(%rdi), %rsi
movq (%rsi,%rdx,8), %r8
movq %r8, -0x8(%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x3bdf
decq %rcx
movq %rcx, 0x18(%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c19
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_O3/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 0x3c80
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %r12
cmpq 0x18(%rsi), %r12
jne 0x3c7e
testq %r12, %r12
je 0x3c80
xorl %r13d, %r13d
cmpq 0x18(%r15), %r13
jae 0x3c57
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %rdi
jmp 0x3c59
xorl %edi, %edi
cmpq 0x18(%r14), %r13
jae 0x3c69
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rsi
jmp 0x3c6b
xorl %esi, %esi
callq 0x37e7
testl %eax, %eax
je 0x3c7e
incq %r13
cmpq %r13, %r12
jne 0x3c47
jmp 0x3c80
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3cb6
movq %rax, %rbx
movq %rax, %rdi
callq 0x584a
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_O3/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 0x3d49
xorl %ebp, %ebp
leaq 0x26d1(%rip), %r15      # 0x63b7
leaq 0x231f(%rip), %r12      # 0x600c
movq 0x20(%rbx), %rax
movq (%rax,%rbp,8), %rdi
cmpq %rbx, %rdi
je 0x3d01
callq 0x36ac
jmp 0x3d09
movq %r15, %rdi
callq 0x11f0
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcc
movq %rax, %r14
movq %r13, %rdi
callq 0x1030
movq 0x18(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %rbp
je 0x3d41
movq %r14, %rdi
movq %r12, %rsi
callq 0x1fcc
movq %rax, %r14
movq 0x18(%rbx), %rax
incq %rbp
cmpq %rbp, %rax
ja 0x3ced
leaq 0x2665(%rip), %rsi      # 0x63b5
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fcc
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3da2
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f3e
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/samsonjs[P]lake/src/parse.c
// Function: parse_expr
static LakeVal *_parse_expr(Ctx *ctx)
{
    maybe_spaces(ctx);

    LakeVal *result;
    char c = peek(ctx);
    /* try to parse a number, if that fails parse a symbol */
    if ((c >= '0' && c <= '9') || c == '-' || c == '+')
    {
        result = VAL(parse_int(ctx));
        if (result == NULL)
        {
            result = parse_sym(ctx);
        }
    }
    else if (is_letter(c) || is_symbol(c))
    {
        result = parse_sym(ctx);
    }
    else if (c == '"')
    {
        result = parse_str(ctx);
    }
    else if (c == '\'')
    {
        result = parse_quoted(ctx);
    }
    else if (c == '(')
    {
        result = parse_list(ctx);
    }
    else if (c == ';')
    {
        result = parse_comment(ctx);
    }
    else if (c == PARSE_EOF)
    {
        result = NULL;
    }
    else
    {
        ERR("unexpected char '%c'", c);
        result = VAL(PARSE_ERR);
        ctx->i = ctx->n; /* consume the rest */
        result = NULL;
    }
    maybe_spaces(ctx);

    return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x407e
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
jae 0x3e6e
movq (%rbx), %rdx
movb (%rdx,%rax), %r14b
leal -0x30(%r14), %esi
cmpb $0xa, %sil
jb 0x3de3
cmpb $0x2d, %r14b
je 0x3de3
movzbl %r14b, %esi
cmpl $0x2b, %esi
jne 0x3ec8
movq %rax, 0x18(%rbx)
movzbl (%rdx,%rax), %ebp
cmpl $0x2d, %ebp
je 0x3df5
cmpl $0x2b, %ebp
jne 0x3e18
movq %rbx, %rdi
callq 0x40c6
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
jae 0x3e64
movq (%rbx), %rdx
movb (%rdx,%rax), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x3e64
xorl %r14d, %r14d
cmpq %rcx, %rax
jae 0x3e52
xorl %r14d, %r14d
movq (%rbx), %rcx
movb (%rcx,%rax), %al
leal -0x3a(%rax), %ecx
cmpb $-0xa, %cl
jb 0x3e54
movzbl %al, %eax
leal (%r14,%r14,4), %ecx
leal (%rax,%rcx,2), %r14d
addl $-0x30, %r14d
movq %rbx, %rdi
callq 0x40c6
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
jb 0x3e23
movb $-0x1, %al
movsbl %al, %edi
callq 0x447d
testl %eax, %eax
je 0x3eed
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
jmp 0x3e8e
movb $-0x1, %r14b
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x25c1(%rip), %rdi      # 0x643e
movl $0x14, %edx
movl %ebp, %esi
callq 0x1120
testq %rax, %rax
je 0x3ea9
movq %rbx, %rdi
callq 0x40de
movq %rax, %r14
movq %rbx, %rdi
callq 0x407e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movzbl %r14b, %eax
cmpl $0x27, %eax
jle 0x3ed9
cmpl $0x28, %eax
je 0x3f09
cmpl $0x3b, %eax
je 0x3f20
cmpl $0xff, %eax
jne 0x3f2d
xorl %r14d, %r14d
jmp 0x3e99
movl %r14d, %eax
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x3e8e
movsbl %r14b, %ebp
jmp 0x3e76
cmpl $0x22, %eax
je 0x3f13
cmpl $0x27, %eax
jne 0x3f2d
movq %rbx, %rdi
callq 0x4292
jmp 0x3e96
movl %r14d, %edi
negl %edi
cmpb $0x2d, %bpl
cmovnel %r14d, %edi
callq 0x35fa
movq %rax, %r14
testq %rax, %rax
jne 0x3e99
jmp 0x3e8e
movq %rbx, %rdi
callq 0x42e4
jmp 0x3e96
movq %rbx, %rdi
callq 0x417b
jmp 0x3e96
movq %rbx, %rdi
callq 0x43d5
jmp 0x3e96
leaq 0x10(%rbx), %rdx
leaq 0x8(%rbx), %rsi
movl %ebp, %edi
callq 0x165f
jmp 0x3ec3
// File: /workspace/github_c_makefile_star2_O3/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 0x407e
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rax
cmpq %rax, %rdx
jbe 0x3f5d
movq (%rbx), %rcx
cmpb $0x3b, (%rcx,%rax)
jne 0x3f5f
popq %rbx
retq
addq %rax, %rcx
movq 0x608f(%rip), %rsi      # 0x9ff8
movq (%rsi), %rdi
subl %eax, %edx
leaq 0x2468(%rip), %rsi      # 0x63dd
xorl %eax, %eax
popq %rbx
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/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 0x38e2
movq %rax, %rbx
testq %r14, %r14
je 0x3fd7
movq %rsp, %r14
movq %r14, %rdi
callq 0x3da2
cmpq $-0x2, %rax
je 0x3fe1
testq %rax, %rax
je 0x3fe1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a63
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x3fad
movq %rsp, %rdi
callq 0x3f3e
jmp 0x3feb
movq %rbx, %rdi
callq 0x38d8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsp, %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %rdi, 0x20(%r14)
callq 0x38e2
movq %rax, %rbx
movq %r14, %rdi
callq 0x407e
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
jae 0x405f
movq %rsp, %r14
movq (%rsp), %rcx
cmpb $-0x1, (%rcx,%rax)
je 0x405f
movq %r14, %rdi
callq 0x3da2
cmpq $-0x2, %rax
je 0x4072
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a63
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x4030
movq %rsp, %rdi
callq 0x3f3e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x38d8
xorl %ebx, %ebx
jmp 0x4067
// File: /workspace/github_c_makefile_star2_O3/samsonjs[P]lake/src/parse.c
// Function: parse_sym
static LakeVal *parse_sym(Ctx *ctx)
{
    LakeVal *val;
    static int size = 1024;
    char s[size];
    char c;
    int i = 0;
    while (is_sym_char(c = peek(ctx)) && i < size - 1)
    {
        s[i++] = c;
        consume1(ctx);
    }
    s[i] = '\0';
    if (strcmp(s, "#t") == 0)
    {
        val = VAL(ctx->lake_ctx->T);
    }
    else if (strcmp(s, "#f") == 0)
    {
        val = VAL(ctx->lake_ctx->F);
    }
    else
    {
        val = VAL(sym_intern(ctx->lake_ctx, s));
    }
    return val;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movb $-0x1, %bpl
cmpq 0x8(%rbx), %rax
jae 0x4103
movq (%rbx), %rcx
movb (%rcx,%rax), %bpl
movsbl %bpl, %edi
callq 0x447d
testl %eax, %eax
je 0x412a
cmpq $0x3fe, %r14            # imm = 0x3FE
ja 0x412a
movb %bpl, (%rsp,%r14)
incq %r14
movq %rbx, %rdi
callq 0x40c6
jmp 0x40ef
movb $0x0, (%rsp,%r14)
movl $0x7423, %eax           # imm = 0x7423
xorl (%rsp), %eax
movzbl 0x2(%rsp), %ecx
orw %ax, %cx
je 0x4161
movl $0x6623, %eax           # imm = 0x6623
xorl (%rsp), %eax
movzbl 0x2(%rsp), %ecx
orw %ax, %cx
movq 0x20(%rbx), %rdi
je 0x416b
movq %rsp, %rsi
callq 0x58f0
jmp 0x416f
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
jmp 0x416f
movq 0x20(%rdi), %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq