LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x4b96
movl $0x1, -0x4(%rbp)
jmp 0x4c75
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x4bbc
movl $0x0, -0x4(%rbp)
jmp 0x4c75
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4c6e
cmpq $0x0, -0x28(%rbp)
jb 0x4bfd
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4bfd
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x4c05
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4c05
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jb 0x4c38
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4c38
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x4c40
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x4c40
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4360
cmpl $0x0, %eax
jne 0x4c5b
movl $0x0, -0x4(%rbp)
jmp 0x4c75
jmp 0x4c5d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4bc4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x28, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4db8
cmpl $0x0, -0x14(%rbp)
jl 0x4d2c
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x4d2c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x4d34
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x4d34
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x4d58
leaq 0x4646(%rip), %rdi      # 0x9393
callq 0x11d0
movq %rax, -0x20(%rbp)
jmp 0x4d65
movq -0x28(%rbp), %rdi
callq 0x40f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x4da8
movq -0x10(%rbp), %rdi
leaq 0x426d(%rip), %rsi      # 0x900c
callq 0x12f0
movq %rax, -0x10(%rbp)
jmp 0x4daa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4cf0
movq -0x10(%rbp), %rdi
leaq 0x45ce(%rip), %rsi      # 0x9391
callq 0x12f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4e30
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4fe0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51e0
movq -0x8(%rbp), %rdi
callq 0x5220
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x30, %eax
jl 0x4e63
movsbl -0x11(%rbp), %eax
cmpl $0x39, %eax
jle 0x4e75
movsbl -0x11(%rbp), %eax
cmpl $0x2d, %eax
je 0x4e75
movsbl -0x11(%rbp), %eax
cmpl $0x2b, %eax
jne 0x4e9b
movq -0x8(%rbp), %rdi
callq 0x5360
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4e96
movq -0x8(%rbp), %rdi
callq 0x5470
movq %rax, -0x10(%rbp)
jmp 0x4fc5
movsbl -0x11(%rbp), %edi
callq 0x5590
cmpl $0x0, %eax
jne 0x4eb7
movsbl -0x11(%rbp), %edi
callq 0x55e0
cmpl $0x0, %eax
je 0x4ec9
movq -0x8(%rbp), %rdi
callq 0x5470
movq %rax, -0x10(%rbp)
jmp 0x4fc3
movsbl -0x11(%rbp), %eax
cmpl $0x22, %eax
jne 0x4ee4
movq -0x8(%rbp), %rdi
callq 0x5610
movq %rax, -0x10(%rbp)
jmp 0x4fc1
movsbl -0x11(%rbp), %eax
cmpl $0x27, %eax
jne 0x4eff
movq -0x8(%rbp), %rdi
callq 0x57b0
movq %rax, -0x10(%rbp)
jmp 0x4fbf
movsbl -0x11(%rbp), %eax
cmpl $0x28, %eax
jne 0x4f1a
movq -0x8(%rbp), %rdi
callq 0x5830
movq %rax, -0x10(%rbp)
jmp 0x4fbd
movsbl -0x11(%rbp), %eax
cmpl $0x3b, %eax
jne 0x4f35
movq -0x8(%rbp), %rdi
callq 0x59e0
movq %rax, -0x10(%rbp)
jmp 0x4fbb
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jne 0x4f48
movq $0x0, -0x10(%rbp)
jmp 0x4fb9
jmp 0x4f4a
movq 0x80a7(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x4103(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x808f(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movsbl -0x11(%rbp), %edx
leaq 0x448e(%rip), %rsi      # 0x9405
movb $0x0, %al
callq 0x1160
movq 0x8073(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x4451(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $-0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x10(%rbp)
jmp 0x4fbb
jmp 0x4fbd
jmp 0x4fbf
jmp 0x4fc1
jmp 0x4fc3
jmp 0x4fc5
movq -0x8(%rbp), %rdi
callq 0x51e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x5059
movq -0x8(%rbp), %rdi
callq 0x5220
movsbl %al, %eax
cmpl $0x3b, %eax
je 0x5059
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x10(%rbp)
movq 0x7fc6(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
subq 0x10(%rcx), %rax
movl %eax, %edx
movq -0x10(%rbp), %rcx
leaq 0x4367(%rip), %rsi      # 0x93b9
movb $0x0, %al
callq 0x1160
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4640
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x50f4
leaq -0x48(%rbp), %rdi
callq 0x4e30
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x50df
movq $-0x2, %rax
cmpq %rax, -0x58(%rbp)
je 0x50df
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x47f0
jmp 0x50f2
movq -0x50(%rbp), %rdi
callq 0x4610
movq $0x0, -0x8(%rbp)
jmp 0x5105
jmp 0x50a5
leaq -0x48(%rbp), %rdi
callq 0x4fe0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4640
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x51e0
leaq -0x48(%rbp), %rdi
callq 0x5220
movb %al, -0x51(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x51b6
leaq -0x48(%rbp), %rdi
callq 0x4e30
movq %rax, -0x60(%rbp)
movq $-0x2, %rax
cmpq %rax, -0x60(%rbp)
jne 0x51a7
movq -0x50(%rbp), %rdi
callq 0x4610
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x51c7
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x47f0
jmp 0x515e
leaq -0x48(%rbp), %rdi
callq 0x4fe0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_int
static LakeVal *parse_int(Ctx *ctx)
{
    mark(ctx);
    int n = 0;
    char c = peek(ctx);
    char sign = c == '-' ? -1 : 1;
    if (c == '-' || c == '+')
    {
        consume1(ctx);
        /* if not followed by a digit it's a symbol */
        if (!is_digit(peek(ctx)))
        {
            backtrack(ctx);
            return NULL;
        }
    }
    while (is_digit(c = peek(ctx)))
    {
        n *= 10;
        n += c - '0';
        consume1(ctx);
    }
    /* if we're looking at a symbol character bail, it's not a number */
    if (is_sym_char(peek(ctx)))
    {
        backtrack(ctx);
        return NULL;
    }
    return VAL(int_from_c(sign * n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5a20
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5220
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x2d, %edx
cmovel %ecx, %eax
movb %al, -0x16(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x2d, %eax
je 0x53b1
movsbl -0x15(%rbp), %eax
cmpl $0x2b, %eax
jne 0x53e5
movq -0x10(%rbp), %rdi
callq 0x5290
movq -0x10(%rbp), %rdi
callq 0x5220
movsbl %al, %edi
callq 0x5a40
cmpl $0x0, %eax
jne 0x53e3
movq -0x10(%rbp), %rdi
callq 0x5a70
movq $0x0, -0x8(%rbp)
jmp 0x5459
jmp 0x53e5
jmp 0x53e7
movq -0x10(%rbp), %rdi
callq 0x5220
movb %al, -0x15(%rbp)
movsbl %al, %edi
callq 0x5a40
cmpl $0x0, %eax
je 0x541f
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movsbl -0x15(%rbp), %eax
subl $0x30, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5290
jmp 0x53e7
movq -0x10(%rbp), %rdi
callq 0x5220
movsbl %al, %edi
callq 0x5a90
cmpl $0x0, %eax
je 0x5448
movq -0x10(%rbp), %rdi
callq 0x5a70
movq $0x0, -0x8(%rbp)
jmp 0x5459
movsbl -0x16(%rbp), %edi
imull -0x14(%rbp), %edi
callq 0x3fb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl 0x7cd6(%rip), %eax      # 0xd158
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5220
movb %al, -0x21(%rbp)
movsbl %al, %edi
callq 0x5a90
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x54e0
movl -0x28(%rbp), %eax
movl 0x7c83(%rip), %ecx      # 0xd158
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x54e9
jmp 0x550c
movq -0x30(%rbp), %rax
movb -0x21(%rbp), %dl
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x5290
jmp 0x54ac
movq -0x30(%rbp), %rdi
movslq -0x28(%rbp), %rax
movb $0x0, (%rdi,%rax)
leaq 0x3ae5(%rip), %rsi      # 0x9004
callq 0x1150
cmpl $0x0, %eax
jne 0x553b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5579
movq -0x30(%rbp), %rdi
leaq 0x3ac1(%rip), %rsi      # 0x9007
callq 0x1150
cmpl $0x0, %eax
jne 0x5562
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5577
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7f30
movq %rax, -0x10(%rbp)
jmp 0x5579
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_str
static LakeVal *parse_str(Ctx *ctx)
{
    size_t n = 8;
    size_t i = 0;
    char *s = malloc(n);
    char c;
    ch(ctx, '"');
    while ((c = peek(ctx)) != PARSE_EOF && c != '"')
    {
        /* handle backslash escapes */
        if (c == '\\')
        {
            consume1(ctx);
            c = escape_char(peek(ctx));
            if (c == PARSE_EOF) break;
        }
        s[i++] = c;
        consume1(ctx);
        /* grow if necessary */
        if (i >= n)
        {
            n *= 2;
            if (!(s = realloc(s, n))) OOM();
        }
    }
    s[i] = '\0';
    ch(ctx, '"');
    LakeStr *str = lake_str_from_c(s);
    free(s);
    return VAL(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x8, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1190
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x5af0
movq -0x8(%rbp), %rdi
callq 0x5220
movb %al, -0x21(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x31(%rbp)
je 0x566d
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5679
jmp 0x576a
movsbl -0x21(%rbp), %eax
cmpl $0x5c, %eax
jne 0x56af
movq -0x8(%rbp), %rdi
callq 0x5290
movq -0x8(%rbp), %rdi
callq 0x5220
movsbl %al, %edi
callq 0x5ba0
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $-0x1, %eax
jne 0x56ad
jmp 0x576a
jmp 0x56af
movb -0x21(%rbp), %dl
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x5290
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x5765
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5763
jmp 0x5703
jmp 0x5705
movq 0x78ec(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3948(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x78d4(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3c70(%rip), %rsi      # 0x939e
leaq 0x3cf9(%rip), %rdx      # 0x942e
movl $0x123, %ecx            # imm = 0x123
movb $0x0, %al
callq 0x1160
movq 0x78b0(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3c8e(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x11c0
jmp 0x5765
jmp 0x5647
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x5af0
movq -0x20(%rbp), %rdi
callq 0x7d20
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_quoted
static LakeVal *parse_quoted(Ctx *ctx)
{
    ch(ctx, '\'');
    LakeList *list = list_make();
    list_append(list, VAL(sym_intern(ctx->lake_ctx, "quote")));
    list_append(list, _parse_expr(ctx));
    return VAL(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x27, %esi
callq 0x5af0
callq 0x4640
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x384a(%rip), %rsi      # 0x9034
callq 0x7f30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x47f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4e30
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x47f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_list
static LakeVal *parse_list(Ctx *ctx)
{
    LakeList *list = list_make();
    ch(ctx, '(');
    char c;
    while ((c = peek(ctx)) != ')')
    {
        if (c == PARSE_EOF)
        {
            ERR("end of input while parsing list");
            list_free(list);
            ctx->i = ctx->n;
            return NULL;
        }

        /* check for dotted lists */
        if (c == '.')
        {
            ch(ctx, '.');
            maybe_spaces(ctx);
            LakeVal *tail = _parse_expr(ctx);
            if (tail == VAL(PARSE_ERR))
            {
                list_free(list);
                ctx->i = ctx->n;
                return NULL;
            }
            ch(ctx, ')');
            return VAL(dlist_make(list, tail));
        }

        LakeVal *val = _parse_expr(ctx);
        if (val == VAL(PARSE_ERR))
        {
            list_free(list);
            ctx->i = ctx->n;
            return NULL;
        }
        list_append(list, val);
    }
    ch(ctx, ')');
    return VAL(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x4640
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x28, %esi
callq 0x5af0
movq -0x10(%rbp), %rdi
callq 0x5220
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x29, %eax
je 0x59b4
movsbl -0x19(%rbp), %eax
cmpl $-0x1, %eax
jne 0x58e4
jmp 0x5876
movq 0x777b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x37d7(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x7763(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3bbb(%rip), %rsi      # 0x945a
movb $0x0, %al
callq 0x1160
movq 0x774b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3b29(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq -0x18(%rbp), %rdi
callq 0x4610
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x59ca
movsbl -0x19(%rbp), %eax
cmpl $0x2e, %eax
jne 0x5965
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x5af0
movq -0x10(%rbp), %rdi
callq 0x51e0
movq -0x10(%rbp), %rdi
callq 0x4e30
movq %rax, -0x28(%rbp)
movq $-0x2, %rax
cmpq %rax, -0x28(%rbp)
jne 0x5944
movq -0x18(%rbp), %rdi
callq 0x4610
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x59ca
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x5af0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1670
movq %rax, -0x8(%rbp)
jmp 0x59ca
movq -0x10(%rbp), %rdi
callq 0x4e30
movq %rax, -0x30(%rbp)
movq $-0x2, %rax
cmpq %rax, -0x30(%rbp)
jne 0x59a2
movq -0x18(%rbp), %rdi
callq 0x4610
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x59ca
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x47f0
jmp 0x5853
movq -0x10(%rbp), %rdi
movl $0x29, %esi
callq 0x5af0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_comment
static LakeVal *parse_comment(Ctx *ctx)
{
    char *text = parse_while(ctx, is_not_newline);
    LakeComment *comment = comment_from_c(text);
    free(text);
    return VAL(comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x339(%rip), %rsi       # 0x5d30
callq 0x5bf0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: ch
static char ch(Ctx *ctx, char expected)
{
    char c = peek(ctx);
    if (c == expected)
    {
        consume1(ctx);
        return c;
    }
    DIE("parse error, expected '%c' got '%c'", expected, c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5220
movb %al, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5b2b
movq -0x8(%rbp), %rdi
callq 0x5290
movb -0xa(%rbp), %al
movb %al, -0xb(%rbp)
jmp 0x5b89
jmp 0x5b2d
jmp 0x5b2f
movq 0x74c2(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x351e(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x74aa(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movsbl -0x9(%rbp), %edx
movsbl -0xa(%rbp), %ecx
leaq 0x38d6(%rip), %rsi      # 0x9436
movb $0x0, %al
callq 0x1160
movq 0x748a(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x3868(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x11c0
movb -0xb(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: escape_char
static char escape_char(char c)
{
    switch (c)
    {

    case 'n':
        c = '\n';
        break;

    case 'r':
        c = '\r';
        break;

    case 't':
        c = '\t';
        break;

    default:
        /* noop */
        break;
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x6e, %eax
je 0x5bcc
jmp 0x5bb8
movl -0x8(%rbp), %eax
subl $0x72, %eax
je 0x5bd2
jmp 0x5bc2
movl -0x8(%rbp), %eax
subl $0x74, %eax
je 0x5bd8
jmp 0x5bde
movb $0xa, -0x1(%rbp)
jmp 0x5be0
movb $0xd, -0x1(%rbp)
jmp 0x5be0
movb $0x9, -0x1(%rbp)
jmp 0x5be0
jmp 0x5be0
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/parse.c
// Function: parse_while
static char *parse_while(Ctx *ctx, bool (*is_valid)(char))
{
    size_t n = 8;
    size_t i = 0;
    char *s = malloc(n);
    char c;
    while ((c = peek(ctx)) != PARSE_EOF && is_valid(c))
    {
        s[i++] = c;
        consume1(ctx);
        /* grow if necessary */
        if (i >= n)
        {
            n *= 2;
            if (!(s = realloc(s, n))) OOM();
        }
    }
    s[i] = '\0';
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x8, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1190
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5220
movb %al, -0x29(%rbp)
movsbl %al, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x2a(%rbp)
je 0x5c49
movq -0x10(%rbp), %rax
movsbl -0x29(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x5c55
jmp 0x5d10
movb -0x29(%rbp), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x5290
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x5d0b
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x11a0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5d09
jmp 0x5ca9
jmp 0x5cab
movq 0x7346(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x33a2(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x732e(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x36ca(%rip), %rsi      # 0x939e
leaq 0x3753(%rip), %rdx      # 0x942e
movl $0xaa, %ecx
movb $0x0, %al
callq 0x1160
movq 0x730a(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x36e8(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movl $0x1, %edi
callq 0x11c0
jmp 0x5d0b
jmp 0x5c1d
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: prim_make
LakePrimitive *prim_make(char *name, int arity, lake_prim fn)
{
    LakePrimitive *prim = prim_alloc();
    prim->name = strdup(name);
    prim->arity = arity;
    prim->fn = fn;
    return prim;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x5de0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: prim_alloc
static LakePrimitive *prim_alloc(void)
{
    LakePrimitive *prim = malloc(sizeof(LakePrimitive));
    VAL(prim)->type = TYPE_PRIM;
    VAL(prim)->size = sizeof(LakePrimitive);
    return prim;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x1190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x7, (%rax)
movq -0x8(%rbp), %rax
movq $0x28, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: prim_repr
char *prim_repr(LakePrimitive *prim)
{
    size_t n = 16 + strlen(prim->name) + MAX_INT_LENGTH;
    char *s = malloc(n);
    snprintf(s, n, "<#primitive:%s(%d)>", prim->name, prim->arity);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10b0
addq $0x10, %rax
addq $0x14, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0x3609(%rip), %rdx      # 0x947a
movb $0x0, %al
callq 0x10e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: car
static LakeVal *_car(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list) && LIST_N(list) > 0)
    {
        return LIST_VAL(list, 0);
    }
    if (lake_is_type(TYPE_DLIST, list))
    {
        return VAL(dlist_head(DLIST(list)));
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x66ed
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x66f5
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x66f5
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x674d
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x674d
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x6738
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6740
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6740
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x67d5
movq -0x20(%rbp), %rsi
movl $0x6, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x676f
movq -0x20(%rbp), %rdi
callq 0x16f0
movq %rax, -0x8(%rbp)
jmp 0x67d5
jmp 0x6771
movq 0x6880(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x28dc(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x6868(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40f0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x2d6e(%rip), %rsi      # 0x951c
movb $0x0, %al
callq 0x1160
movq 0x683c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2c1a(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: cdr
static LakeVal *_cdr(LakeCtx *ctx, LakeList *args)
{
    LakeList *list = LIST(LIST_VAL(args, 0));
    if (lake_is_type(TYPE_LIST, list) && LIST_N(list) > 0)
    {
        LakeList *cdr = list_copy(list);
        list_shift(cdr);
        return VAL(cdr);
    }
    if (lake_is_type(TYPE_DLIST, list))
    {
        return dlist_tail(DLIST(list));
    }
    ERR("not a pair: %s", lake_repr(list));
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
jae 0x680d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6815
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6815
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x685e
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x685e
movq -0x20(%rbp), %rdi
callq 0x4910
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4a90
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x68e6
movq -0x20(%rbp), %rsi
movl $0x6, %edi
callq 0x40d0
cmpl $0x0, %eax
je 0x6880
movq -0x20(%rbp), %rdi
callq 0x1710
movq %rax, -0x8(%rbp)
jmp 0x68e6
jmp 0x6882
movq 0x676f(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x27cb(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x6757(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x40f0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x2c5d(%rip), %rsi      # 0x951c
movb $0x0, %al
callq 0x1160
movq 0x672b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2b09(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: nullP
static LakeVal *_nullP(LakeCtx *ctx, LakeList *args)
{
    LakeVal *val = list_shift(args);
    LakeBool *is_null = lake_bool_from_int(ctx, lake_is_type(TYPE_LIST, val) &&
                                                    LIST_N(LIST(val)) == 0);
    return VAL(is_null);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movl $0x5, %edi
callq 0x40d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x69ce
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
sete %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rdi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1540
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: add
static LakeVal *_add(LakeCtx *ctx, LakeList *args)
{
    int result = 0;
    size_t n = LIST_N(args);
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result += INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6d0b
cmpq $0x0, -0x30(%rbp)
jb 0x6c54
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x6c54
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x6c5c
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x6c5c
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x6ceb
jmp 0x6c79
movq 0x6378(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x23d4(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x6360(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
leaq 0x2869(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x6328(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2706(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x6d17
jmp 0x6ced
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6c1b
movl -0x1c(%rbp), %edi
callq 0x3fb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: sub
static LakeVal *_sub(LakeCtx *ctx, LakeList *args)
{
    size_t n = LIST_N(args);

    if (n < 1)
    {
        ERR("- requires at least one argument");
        return NULL;
    }

    int result = 0;
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result -= INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jae 0x6daa
jmp 0x6d55
movq 0x629c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x22f8(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x6284(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x27d0(%rip), %rsi      # 0x954e
movb $0x0, %al
callq 0x1160
movq 0x626c(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x264a(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x6eb7
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6eab
cmpq $0x0, -0x30(%rbp)
jb 0x6df2
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x6df2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x6dfa
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x6dfa
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x6e89
jmp 0x6e17
movq 0x61da(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2236(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x61c2(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
leaq 0x26cb(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x618a(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2568(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x6eb7
jmp 0x6e8b
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6db9
movl -0x24(%rbp), %edi
callq 0x3fb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: mul
static LakeVal *_mul(LakeCtx *ctx, LakeList *args)
{
    int result = 1;
    size_t n = LIST_N(args);
    size_t i;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        result *= INT_VAL(INT(v));
    }
    return VAL(int_from_c(result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6fec
cmpq $0x0, -0x30(%rbp)
jb 0x6f34
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x6f34
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x6f3c
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x6f3c
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x6fcb
jmp 0x6f59
movq 0x6098(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x20f4(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x6080(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x40f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
leaq 0x2589(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x6048(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2426(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x6ff8
jmp 0x6fcd
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6efb
movl -0x1c(%rbp), %edi
callq 0x3fb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: int_eq
static LakeVal *_int_eq(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;
    for (i = 0; i < n; ++i)
    {
        LakeVal *v = LIST_VAL(args, i);
        ENSURE_INT(v, i);
        curr = INT_VAL(INT(v));
        if (i > 0)
        {
            result = result && curr == prev;
        }
        prev = INT_VAL(INT(v));
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x747b
cmpq $0x0, -0x30(%rbp)
jb 0x7394
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x7394
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x739c
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x739c
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x742b
jmp 0x73b9
movq 0x5c38(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1c94(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x5c20(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x2129(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x5be8(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1fc6(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x748b
jmp 0x742d
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x7460
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x59(%rbp)
je 0x7455
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x735b
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: int_lt
static LakeVal *_int_lt(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;

    if (n > 1)
    {
        for (i = 0; i < n; ++i)
        {
            LakeVal *v = LIST_VAL(args, i);
            ENSURE_INT(v, i);
            curr = INT_VAL(INT(v));
            if (i > 0)
            {
                result = result && prev < curr;
            }
            prev = INT_VAL(INT(v));
        }
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jbe 0x75f8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x75f6
cmpq $0x0, -0x30(%rbp)
jb 0x750f
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x750f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x7517
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x7517
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x75a6
jmp 0x7534
movq 0x5abd(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1b19(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x5aa5(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x1fae(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x5a6d(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1e4b(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x7608
jmp 0x75a8
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x75db
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x59(%rbp)
je 0x75d0
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
setl %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x74d6
jmp 0x75f8
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samsonjs[P]lake/src/primitive.c
// Function: int_gt
static LakeVal *_int_gt(LakeCtx *ctx, LakeList *args)
{
    bool result = TRUE;
    size_t n = LIST_N(args);
    size_t i;
    int curr, prev;

    if (n > 1)
    {
        for (i = 0; i < n; ++i)
        {
            LakeVal *v = LIST_VAL(args, i);
            ENSURE_INT(v, i);
            curr = INT_VAL(INT(v));
            if (i > 0)
            {
                result = result && prev > curr;
            }
            prev = INT_VAL(INT(v));
        }
    }
    return VAL(lake_bool_from_int(ctx, result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x1, -0x28(%rbp)
jbe 0x7778
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x7776
cmpq $0x0, -0x30(%rbp)
jb 0x768f
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x768f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x7697
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x7697
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movl $0x3, %edi
callq 0x40d0
cmpl $0x0, %eax
jne 0x7726
jmp 0x76b4
movq 0x593d(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1999(%rip), %rsi      # 0x905e
movb $0x0, %al
callq 0x1160
movq 0x5925(%rip), %rax      # 0xcff8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x1e2e(%rip), %rsi      # 0x952b
movb $0x0, %al
callq 0x1160
movq 0x58ed(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x1ccb(%rip), %rsi      # 0x93e0
movb $0x0, %al
callq 0x1160
movq $0x0, -0x8(%rbp)
jmp 0x7788
jmp 0x7728
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x775b
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x59(%rbp)
je 0x7750
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7656
jmp 0x7778
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)