LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do
int compiler_do(compiler_t *comp, ast_t *ast, ins_t *ins)
{
    assert(ins != NULL);
    int status = ERR;
    switch (ast->kind) {
        case AST_IDENTIFIER:
            status = compiler_do_ident(comp, ast, ins);
            break;
        case AST_INTEGER:
            status = compiler_do_int(comp, ast, ins);
            break;
        case AST_CONS:
            status = compiler_do_cons(comp, ast, ins);
            break;
        default :
            string_printf(comp->error, "Don't know how to compile: %d", ast->kind);
            return ERR;
    }
    ins_t *asm_ins = compiler_assemby(comp, ins);
    /* FIXME: 此处需要一个复制操作，将汇编后的指令复制到作为结果的ins变量中 */
    memcpy(ins, asm_ins, sizeof(ins_t));
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x732d
jmp 0x734c
leaq 0x34d1(%rip), %rdi      # 0xa805
leaq 0x34d6(%rip), %rsi      # 0xa811
movl $0x158, %edx            # imm = 0x158
leaq 0x34d5(%rip), %rcx      # 0xa81c
callq 0x2060
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x73a3
jmp 0x7363
movl -0x34(%rbp), %eax
subl $0x4, %eax
je 0x7377
jmp 0x736d
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x738d
jmp 0x73b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7420
movl %eax, -0x24(%rbp)
jmp 0x73de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7520
movl %eax, -0x24(%rbp)
jmp 0x73de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x75a0
movl %eax, -0x24(%rbp)
jmp 0x73de
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x347e(%rip), %rsi      # 0xa84c
movb $0x0, %al
callq 0x9340
movl $0x0, -0x4(%rbp)
jmp 0x7413
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7670
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_ident
static int compiler_do_ident(compiler_t *comp, ast_t *id, ins_t *ins)
{
    int i = 0, j = 0;
    char *name = AST_IDENT_NAME(id);
    /* In current lexical environment */
    if (env_locate(comp->env, name, &i, &j) == OK) {
        ins_push(ins, bc_ref_new(i, j, name));
        return OK;
    }
    /* In global environment */
    if (env_locate(comp->global_env, name, &i, &j) == OK) {
        ins_push(ins, bc_gref_new(i, j, name));
        return OK;
    }
    /* Undefined */
    string_printf(comp->error, "Line %d, column %d: Can't find value of `%s'", id->line, id->column, name);
    return ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x7f60
cmpl $0x1, %eax
jne 0x749b
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x63e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
jmp 0x7514
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x24(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x7f60
cmpl $0x1, %eax
jne 0x74e5
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x6260
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
jmp 0x7514
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x30(%rbp), %r8
leaq 0x2f03(%rip), %rsi      # 0xa409
movb $0x0, %al
callq 0x9340
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_int
static int compiler_do_int(compiler_t *comp, ast_t *n, ins_t *ins)
{
    assert(ins != NULL);
    value_t *v = value_int_new(AST_INT_VALUE(n));
    ins_push(ins, bc_push_new(v));
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x753d
jmp 0x755c
leaq 0x32c1(%rip), %rdi      # 0xa805
leaq 0x32c6(%rip), %rsi      # 0xa811
movl $0x69, %edx
leaq 0x331b(%rip), %rcx      # 0xa872
callq 0x2060
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x26e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x63b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_cons
static int compiler_do_cons(compiler_t *comp, ast_t *cons, ins_t *ins)
{
    ast_t *op = AST_CONS_CAR(cons);
    if (op->kind != AST_IDENTIFIER) {
        string_printf(comp->error, "Line %d, column %d: The first element must be an identifier: %d", op->line, op->column, op->kind);
        return 0;
    }

    char *name = AST_IDENT_NAME(op);
    compiler_rt_t rt = compiler_getrt(comp, name);
    if (rt == NULL) {
        return compiler_do_call(comp, op, AST_CONS_CDR(cons), ins);
    }
    return (*rt)(comp, AST_CONS_CDR(cons), ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x75fd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl (%rax), %r8d
leaq 0x32b9(%rip), %rsi      # 0xa8a6
movb $0x0, %al
callq 0x9340
movl $0x0, -0x4(%rbp)
jmp 0x765b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x77b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x7642
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x77e0
movl %eax, -0x4(%rbp)
jmp 0x765b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_mklabel
static bytecode_t *compiler_mklabel(compiler_t *comp)
{
    char name[32] = {0};
    snprintf(name, sizeof(name), "LABEL%d", comp->counter);
    bytecode_t *label = bc_label_new(name);
    comp->counter++;
    return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2070
leaq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x20, %esi
leaq 0x3198(%rip), %rdx      # 0xa86a
movb $0x0, %al
callq 0x2050
leaq -0x30(%rbp), %rdi
callq 0x6340
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_extend_scope
static int compiler_extend_scope(compiler_t *comp, ast_t *pars)
{
    int i = 0;
    comp->env = env_new(comp->env);
    while (pars->kind == AST_CONS) {
        ast_t *par = AST_CONS_CAR(pars);
        env_push(comp->env, AST_IDENT_NAME(par), NULL, NULL, NULL);
        pars = AST_CONS_CDR(pars);
        i++;
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x777e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x7df0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x772f
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_call
static int compiler_do_call(compiler_t *comp, ast_t *op, ast_t *args, ins_t *ins)
{
    int nargs = 0;
    while (args->kind == AST_CONS) {
        ast_t *expr = AST_CONS_CAR(args);
        if (compiler_do(comp, expr, ins) == ERR)
            return ERR;
        args = AST_CONS_CDR(args);
        nargs++;
    }
    if (compiler_do(comp, op, ins) == ERR)
        return ERR;
    ins_push(ins, bc_call_new(nargs));
    ins_push(ins, bc_chkex_new());
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x784a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x7833
movl $0x0, -0x4(%rbp)
jmp 0x78a5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x77ff
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x7869
movl $0x0, -0x4(%rbp)
jmp 0x78a5
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %edi
callq 0x6170
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x61a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_assembly_scan
static void compiler_assembly_scan(compiler_t *comp, ins_t *ins)
{
    int i = 0, offset = 0;
    while (i < ins_length(ins)) {
        bytecode_t *bc = ins_ref(ins, i);
        if (BC_OPCODE(bc) == BC_LABEL)
            hash_table_set(comp->label_table, BC_LABEL_NAME(bc), (void *)offset);
        else
            offset++;
        i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7928
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9730
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x7914
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
movslq -0x18(%rbp), %rdx
callq 0x8b30
jmp 0x791d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x78ce
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_assembly_rebuild
static ins_t *compiler_assembly_rebuild(compiler_t *comp, ins_t *ins)
{
    ins_t *asm_ins = ins_new();
    int i = 0;
    while (i < ins_length(ins)) {
        bytecode_t *bc = ins_ref(ins, i);
        if (BC_OPCODE(bc) == BC_FJUMP) {
            BC_FJUMP_INDEX(bc) = (int)hash_table_get(comp->label_table, BC_FJUMP_LABEL_NAME(bc), NULL);
            ins_push(asm_ins, bc);
        } else if (BC_OPCODE(bc) == BC_JUMP) {
            BC_JUMP_INDEX(bc) = (int)hash_table_get(comp->label_table, BC_JUMP_LABEL_NAME(bc), NULL);
            ins_push(asm_ins, bc);
        } else if (BC_OPCODE(bc) != BC_LABEL)
            ins_push(asm_ins, bc);
        i++;
    }
    return asm_ins;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x94a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7a1d
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x79b4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c70
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9580
jmp 0x7a0f
movq -0x28(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x79f5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c70
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9580
jmp 0x7a0d
movq -0x28(%rbp), %rax
cmpl $0xc, (%rax)
je 0x7a0b
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9580
jmp 0x7a0d
jmp 0x7a0f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7950
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/parser.c
// Function: parser_getast
ast_kind_t parser_getast(parser_t *parser, ast_t **ast)
{
    lexer_t *l = parser->lexer;
    token_t token = lexer_gettoken(l);
    switch (token) {
        case TOKEN_EOF:
            return AST_END_OF_FILE;
        case TOKEN_IDENTIFIER:
            return parser_getidentifier(parser, ast);
        case TOKEN_INTEGER:
            return parser_getinteger(parser, ast);
        case TOKEN_LEFT_PAREN:
            return parser_getcons(parser, ast);
        case TOKEN_RIGHT_PAREN:
            return AST_RIGHT_PAREN;
        case TOKEN_INVALID:
            if (ast != NULL)
                *ast = ast_invalid_new();
            return AST_INVALID;
        default :
            fprintf(stderr, "Unknown token: %d", token);
            exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8750
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x7b32
movq -0x30(%rbp), %rax
leaq 0x2e29(%rip), %rcx      # 0xa8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x7b57
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b60
movl %eax, -0x4(%rbp)
jmp 0x7b57
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7bc0
movl %eax, -0x4(%rbp)
jmp 0x7b57
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7c30
movl %eax, -0x4(%rbp)
jmp 0x7b57
movl $0x6, -0x4(%rbp)
jmp 0x7b57
cmpq $0x0, -0x18(%rbp)
je 0x7b29
callq 0x82f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7b57
movq 0x74bf(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movl -0x24(%rbp), %edx
leaq 0x2dba(%rip), %rsi      # 0xa900
movb $0x0, %al
callq 0x20c0
movl $0x1, %edi
callq 0x2120
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/parser.c
// Function: parser_getidentifier
static ast_kind_t parser_getidentifier(parser_t *parser, ast_t **ast)
{
    lexer_t *lexer = parser->lexer;
    const char *text = lexer->text->text;
    if (ast != NULL) {
        *ast = ast_ident_new(text);
        parser_posast(parser, *ast);
    }
    return AST_IDENTIFIER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7bb4
movq -0x20(%rbp), %rdi
callq 0x8390
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7d40
movl $0x4, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/parser.c
// Function: parser_getinteger
static ast_kind_t parser_getinteger(parser_t *parser, ast_t **ast)
{
    lexer_t *lexer = parser->lexer;
    const char *text = lexer->text->text;
    if (ast != NULL) {
        *ast = ast_int_new(atoi(text));
        parser_posast(parser, *ast);
    }
    return AST_INTEGER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c1b
movq -0x20(%rbp), %rdi
callq 0x2110
movl %eax, %edi
callq 0x83e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7d40
movl $0x5, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/parser.c
// Function: parser_getcons
static ast_kind_t parser_getcons(parser_t *parser, ast_t **ast)
{
    int line = parser->lexer->tk_line;
    int column = parser->lexer->tk_column;

    ast_t *car = NULL;
    ast_kind_t kind = parser_getast(parser, &car);
    if (kind == AST_INVALID) {
        if (ast != NULL)
            *ast = car;
        return AST_INVALID;
    }
    if (kind == AST_RIGHT_PAREN) {
        if (ast != NULL)
            *ast = ast_eoc_new();
        return AST_END_OF_CONS;
    }
    ast_t *cdr = NULL;
    if (parser_getcons(parser, &cdr) == AST_INVALID) {
        if (ast != NULL)
            *ast = cdr;
        return AST_INVALID;
    }
    if (ast != NULL) {
        *ast = ast_cons_new(car, cdr);
        (*ast)->line = line;
        (*ast)->column = column;
    }
    return AST_CONS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7a80
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x7c96
cmpq $0x0, -0x18(%rbp)
je 0x7c8a
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7d2f
cmpl $0x6, -0x2c(%rbp)
jne 0x7cbb
cmpq $0x0, -0x18(%rbp)
je 0x7cb2
callq 0x8370
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x7d2f
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7c30
cmpl $0x0, %eax
jne 0x7cf0
cmpq $0x0, -0x18(%rbp)
je 0x7ce7
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7d2f
cmpq $0x0, -0x18(%rbp)
je 0x7d28
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_new
env_t *env_new(env_t *outer)
{
    env_t *env = malloc(sizeof(env_t));
    vector_init(&env->data);
    env->outer = outer;
    return env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9460
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_push
void env_push(env_t *env, const char *name, value_t *value, int *index, int *offset)
{
    if (index != NULL)
        *index = 0;
    if (offset != NULL)
        *offset = env->data.count;
    binding_t *b = binding_new(name, value);
    vector_push(&env->data, (intptr_t)b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x7e1d
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x7e34
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7e60
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9580
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_set
void env_set(env_t *env, const char *name, value_t *value)
{
    for (int i = 0; i < env->data.count; i++) {
        binding_t *b = (binding_t *)vector_ref(&env->data, i);
        if (b->name != NULL && strcmp(b->name, name) == 0) {
            b->value = value;
            return;
        }
    }
    binding_t *b = binding_new(name, value);
    vector_push(&env->data, (intptr_t)b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x7f14
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7f07
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20b0
cmpl $0x0, %eax
jne 0x7f07
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7f32
jmp 0x7f09
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7ebb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7e60
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9580
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_locate
int env_locate(env_t *env, const char *name, int *index, int *offset)
{
    int i = 0;
    while (!env_isempty(env)) {
        for (int j = 0; j < env->data.count; j++) {
            binding_t *b = (binding_t *)vector_ref(&env->data, j);
            if (b->name != NULL && strcmp(b->name, name) == 0) {
                if (index != NULL)
                    *index = i;
                if (offset != NULL)
                    *offset = j;
                return OK;
            }
        }
        env = env->outer;
        i++;
    }
    return ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f40
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7f99
jmp 0x802e
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8014
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x9730
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0x8007
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20b0
cmpl $0x0, %eax
jne 0x8007
cmpq $0x0, -0x20(%rbp)
je 0x7fee
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x7ffe
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x8035
jmp 0x8009
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7fa0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7f7f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_update
int env_update(env_t *env, int index, int offset, value_t *value)
{
    for (int i = 0; i < index && env != NULL; i++)
        env = env->outer;
    if (env == NULL || offset > env->data.count - 1)
        return ERR;
    binding_t *b = (binding_t *)vector_ref(&env->data, offset);
    b->value = value;
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x8075
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x807e
jmp 0x8095
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x805d
cmpq $0x0, -0x10(%rbp)
je 0x80b1
movslq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x80ba
movl $0x0, -0x4(%rbp)
jmp 0x80de
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x9730
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_get
value_t *env_get(env_t *env, const char *name)
{
    while (!env_isempty(env)) {
        for (int i = 0; i < env->data.count; i++) {
            binding_t *b = (binding_t *)vector_ref(&env->data, i);
            if (b->name != NULL && strcmp(b->name, name) == 0)
                return b->value;
        }
        env = env->outer;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f40
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8117
jmp 0x8188
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x8177
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x816a
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20b0
cmpl $0x0, %eax
jne 0x816a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8190
jmp 0x816c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x811e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_ref
value_t *env_ref(env_t *env, int index, int offset)
{
    for (int i = 0; i < index && env != NULL; i++)
        env = env->outer;
    if (env == NULL || offset > env->data.count - 1)
        return NULL;
    binding_t *b = (binding_t *)vector_ref(&env->data, offset);
    return (value_t *)b->value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x81d1
cmpq $0x0, -0x10(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x81da
jmp 0x81f1
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x81b9
cmpq $0x0, -0x10(%rbp)
je 0x820d
movslq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x8217
movq $0x0, -0x8(%rbp)
jmp 0x8234
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/env.c
// Function: env_getaddr
value_t **env_getaddr(env_t *env, const char *name)
{
    while (!env_isempty(env)) {
        for (int i = 0; i < env->data.count; i++) {
            binding_t *b = (binding_t *)vector_ref(&env->data, i);
            if (b->name != NULL && strcmp(b->name, name) == 0)
                return (value_t **)&b->value;
        }
        env = env->outer;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7f40
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x8267
jmp 0x82d8
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x82c7
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x82ba
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20b0
cmpl $0x0, %eax
jne 0x82ba
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x82e0
jmp 0x82bc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x826e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8250
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_cons_new
ast_t *ast_cons_new(ast_t *car, ast_t *cdr)
{
    ast_t *a = ast_alloc(AST_CONS);
    a->u.cons_val.car = car;
    a->u.cons_val.cdr = cdr;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
callq 0x8300
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_ident_new
ast_t *ast_ident_new(const char *id)
{
    ast_t *a = ast_alloc(AST_IDENTIFIER);
    a->u.ident_val = string_new();
    string_assign(a->u.ident_val, id);
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, %edi
callq 0x8300
movq %rax, -0x10(%rbp)
callq 0x9170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x92b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_free
void ast_free(ast_t *a)
{
    switch (a->kind) {
        case AST_CONS:
            ast_free(a->u.cons_val.car);
            ast_free(a->u.cons_val.cdr);
            break;
        case AST_IDENTIFIER:
            string_free(a->u.ident_val);
            break;
        default :;
    }
    free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x8436
jmp 0x842c
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x8452
jmp 0x8461
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8410
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8410
jmp 0x8463
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x91a0
jmp 0x8463
jmp 0x8463
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_print
void ast_print(ast_t *a, FILE *output)
{
    switch (a->kind) {
        case AST_CONS:
            ast_print_cons(a, output);
            break;
        case AST_END_OF_CONS:
            fprintf(output, "()");
            break;
        case AST_IDENTIFIER:
            fprintf(output, "%s", a->u.ident_val->text);
            break;
        case AST_INTEGER:
            fprintf(output, "%d", AST_INT_VALUE(a));
            break;
        default :
            fprintf(stderr, "Don't know how to print: %d", a->kind);
            exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x8514
movq -0x18(%rbp), %rax
leaq 0x2466(%rip), %rcx      # 0xa914
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8550
jmp 0x853c
movq -0x10(%rbp), %rdi
leaq 0x1bf2(%rip), %rsi      # 0xa0c3
movb $0x0, %al
callq 0x20c0
jmp 0x853c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
leaq 0x1bdd(%rip), %rsi      # 0xa0cd
movb $0x0, %al
callq 0x20c0
jmp 0x853c
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x235c(%rip), %rsi      # 0xa867
movb $0x0, %al
callq 0x20c0
jmp 0x853c
movq 0x6add(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x23fd(%rip), %rsi      # 0xa928
movb $0x0, %al
callq 0x20c0
movl $0x1, %edi
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_print_cons
static void ast_print_cons(ast_t *cons, FILE *output)
{
    ast_t *car = cons->u.cons_val.car;
    ast_t *cdr = cons->u.cons_val.cdr;
    fputc('(', output);
    ast_print(car, output);
    if (cdr->kind != AST_END_OF_CONS) {
        fprintf(output, " . ");
        ast_print(cdr, output);
    }
    fputc(')', output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movl $0x28, %edi
callq 0x2090
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8480
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
je 0x85bb
movq -0x10(%rbp), %rdi
leaq 0x1b63(%rip), %rsi      # 0xa10a
movb $0x0, %al
callq 0x20c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8480
movq -0x10(%rbp), %rsi
movl $0x29, %edi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: ast_cons_length
int ast_cons_length(ast_t *cons)
{
    assert(cons->kind == AST_CONS || cons->kind == AST_END_OF_CONS);
    int i = 0;
    while (cons->kind != AST_END_OF_CONS) {
        i++;
        cons = AST_CONS_CDR(cons);
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
je 0x85ee
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x85f0
jmp 0x860f
leaq 0x234d(%rip), %rdi      # 0xa944
leaq 0x237e(%rip), %rsi      # 0xa97c
movl $0x72, %edx
leaq 0x2378(%rip), %rcx      # 0xa982
callq 0x2060
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
je 0x8636
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8616
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ast.c
// Function: is_valof_form
int is_valof_form(ast_t *expr)
{
    if (expr->kind == AST_CONS
            && AST_CONS_CAR(expr)->kind == AST_IDENTIFIER
            && strcmp(AST_IDENT_NAME( AST_CONS_CAR(expr) ), "valof") == 0
            && AST_CONS_CADR(expr)->kind == AST_IDENTIFIER)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x869c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, (%rax)
jne 0x869c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x1d85(%rip), %rsi      # 0xa3fd
callq 0x20b0
cmpl $0x0, %eax
jne 0x869c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x4, (%rax)
jne 0x869c
movl $0x1, -0x4(%rbp)
jmp 0x86a3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_new
lexer_t *lexer_new(FILE *src)
{
    lexer_t *l = malloc(sizeof(lexer_t));
    l->src = src;
    l->text = string_new();
    l->tk_line = l->line = 1;
    l->tk_column = l->column = 0;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x9170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_gettoken
token_t lexer_gettoken(lexer_t *l)
{
    int c = lexer_getc(l);
    switch (c) {
        case EOF: return TOKEN_EOF;
        case ' ': case '\n': case '\t': return lexer_gettoken(l);
        case '(': return TOKEN_LEFT_PAREN;
        case ')': return TOKEN_RIGHT_PAREN;
        case ';':
            lexer_skip_comment(l);
            return lexer_gettoken(l);
        default :
            if (isdigit(c))
                return lexer_getinteger(l, c);
            else
                return lexer_getidentifier(l, c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8810
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3c, %eax
ja 0x87cc
movq -0x20(%rbp), %rax
leaq 0x221d(%rip), %rcx      # 0xa9a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x8806
movq -0x10(%rbp), %rdi
callq 0x8750
movl %eax, -0x4(%rbp)
jmp 0x8806
movl $0x4, -0x4(%rbp)
jmp 0x8806
movl $0x5, -0x4(%rbp)
jmp 0x8806
movq -0x10(%rbp), %rdi
callq 0x8870
movq -0x10(%rbp), %rdi
callq 0x8750
movl %eax, -0x4(%rbp)
jmp 0x8806
callq 0x2130
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x87f7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x88b0
movl %eax, -0x4(%rbp)
jmp 0x8806
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8940
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_getc
static int lexer_getc(lexer_t *l)
{
    int c = fgetc(l->src);
    if (c == '\n') {
        l->line++;
        l->column = 0;
    } else
        l->column++;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2080
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jne 0x884b
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x8858
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_getinteger
static token_t lexer_getinteger(lexer_t *l, int start)
{
    l->tk_line = l->line;
    l->tk_column = l->column;

    string_clear(l->text);
    int c = start;
    do {
        string_addc(l->text, c);
        c = lexer_getc(l);
    } while (isdigit(c));
    lexer_ungetc(l, c);
    return TOKEN_INTEGER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9300
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %eax
movsbl %al, %esi
callq 0x91d0
movq -0x8(%rbp), %rdi
callq 0x8810
movl %eax, -0x10(%rbp)
callq 0x2130
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x88ee
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x89d0
movl $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_getidentifier
static token_t lexer_getidentifier(lexer_t *l, int start)
{
    l->tk_line = l->line;
    l->tk_column = l->column;

    string_clear(l->text);
    int c = start;
    do {
        string_addc(l->text, c);
        c = lexer_getc(l);
    } while (!lexer_issep(c));
    lexer_ungetc(l, c);
    return TOKEN_IDENTIFIER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9300
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %eax
movsbl %al, %esi
callq 0x91d0
movq -0x8(%rbp), %rdi
callq 0x8810
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x8a20
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x897e
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x89d0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/lexer.c
// Function: lexer_ungetc
static int lexer_ungetc(lexer_t *l, int c)
{
    if (c == '\n') {
        l->line--;
        /* XXX: 此处l->column应当设置为上一行的长度 */
    } else
        l->column--;
    return ungetc(c, l->src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jne 0x89f4
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x8a01
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x20f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/utils/hash_table.c
// Function: hash_table_new
hash_table_t *hash_table_new(hash_func_t hash_func, comp_func_t comp_func)
{
#define TABLE_SIZE 11
    hash_table_t *tbl = malloc(sizeof(hash_table_t));
    tbl->capacity = TABLE_SIZE;
    tbl->slots = calloc(tbl->capacity, sizeof(table_entry_t *));
    tbl->count = 0;
    tbl->comp_func = comp_func;
    tbl->hash_func = hash_func;
    return tbl;
#undef TABLE_SIZE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0xb, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x8, %esi
callq 0x20a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/utils/hash_table.c
// Function: hash_table_set
void hash_table_set(hash_table_t *tbl, void *key, void *value)
{
    size_t i = hash_table_hash(tbl, key);
    table_entry_t *ent = tbl->slots[i];
    while (ent != NULL) {
        if (hash_table_iseq(tbl, ent->key, key))
            break;
        ent = ent->next;
    }
    if (ent == NULL) {
        ent = malloc(sizeof(table_entry_t));
        ent->key = key;
        ent->next = tbl->slots[i];
        tbl->slots[i] = ent;
    }
    ent->value = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8c00
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8b98
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x8c40
cmpl $0x0, %eax
je 0x8b8a
jmp 0x8b98
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8b68
cmpq $0x0, -0x28(%rbp)
jne 0x8be2
movl $0x18, %edi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/utils/hash_table.c
// Function: hash_table_get
void *hash_table_get(hash_table_t *tbl, void *key, int *is_found)
{
    size_t i = hash_table_hash(tbl, key);
    table_entry_t *ent = tbl->slots[i];
    while (ent != NULL) {
        if (hash_table_iseq(tbl, ent->key, key)) {
            if (is_found != NULL)
                *is_found = 1;
            return ent->value;
        }
        ent = ent->next;
    }
    if (is_found != NULL)
        *is_found = 0;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8c00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8cf5
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x8c40
cmpl $0x0, %eax
je 0x8ce7
cmpq $0x0, -0x20(%rbp)
je 0x8cd9
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8d0e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x8ca8
cmpq $0x0, -0x20(%rbp)
je 0x8d06
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/utils/hash_table.c
// Function: hash_str
size_t hash_str(void *str)
{
    const char *_str = str;
    unsigned int seed = 131;
    unsigned int hash = 0;
    while (*_str != '\0') {
        hash = hash * seed + (*_str);
        _str++;
    }
    return hash & 0x7FFFFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x83, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x8d7b
movl -0x18(%rbp), %eax
imull -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8d4e
movl -0x18(%rbp), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/utils/seg_vector.c
// Function: seg_vector_new
seg_vector_t *seg_vector_new(seg_vector_t *next)
{
    seg_vector_t *sv = malloc(sizeof(*sv));
    sv->data = vector_new();
    sv->next = next;
    return sv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x20d0
movq %rax, -0x10(%rbp)
callq 0x94a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop