LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/vm.c
// Function: vm_restore
static void vm_restore(vm_t *vm, ins_t **ins, value_t **_fun_)
{
    *_fun_ = (value_t *)stack_pop(vm->sys_stack);
    /* 恢复指令指针 */
    vm->ip = (int)stack_pop(vm->sys_stack);
    /* 恢复指令信息 */
    *ins = (ins_t *)stack_pop(vm->sys_stack);
    /* 恢复环境信息 */
    vm->env = (env_t *)stack_pop(vm->sys_stack);
    vm->denv = (env_t *)stack_pop(vm->sys_stack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x6286
movq %rax, (%r14)
movq 0x38(%rbx), %rdi
callq 0x6286
movl %eax, 0x4(%rbx)
movq 0x38(%rbx), %rdi
callq 0x6286
movq %rax, (%r15)
movq 0x38(%rbx), %rdi
callq 0x6286
movq %rax, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x6286
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/vm.c
// Function: vm_trace_callbif
static void vm_trace_callbif(vm_t *vm, value_t *f, ...)
{
    ident_t *id = NULL;
    if (!is_traced(vm, f, &id))
        return;
    vm_trace_space(vm);
    fprintf(TRACE_OUTPUT, "[%d] %s(", vm->depth, IDENT_NAME(id));
    va_list ap;
    va_start(ap, f);
    value_t *arg = va_arg(ap, value_t *);
    while (arg != NULL) {
        value_print(arg, TRACE_OUTPUT);
        arg = va_arg(ap, value_t *);
        if (arg != NULL)
            fprintf(TRACE_OUTPUT, ", ");
    }
    fprintf(TRACE_OUTPUT, ")\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3163
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x28(%rdi), %rdi
xorl %edx, %edx
callq 0x5d56
testq %rax, %rax
je 0x3268
movq %rax, %r14
movq %rbx, %rdi
callq 0x32ee
movq 0x7e47(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movl (%rbx), %edx
movq (%r14), %rcx
leaq 0x40c8(%rip), %rsi      # 0x7260
xorl %eax, %eax
callq 0x20d0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x31e1
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x31ef
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x324f
leaq 0x406b(%rip), %rbx      # 0x7269
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2755
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3222
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3230
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x324f
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2140
jmp 0x31fe
movq (%r15), %rcx
leaq 0x4013(%rip), %rdi      # 0x726c
movl $0x2, %esi
movl $0x1, %edx
callq 0x2140
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/vm.c
// Function: vm_trace_retbif
static void vm_trace_retbif(vm_t *vm, value_t *f, value_t *res)
{
    ident_t *id = NULL;
    if (!is_traced(vm, f, &id))
        return;
    vm_trace_space(vm);
    fprintf(TRACE_OUTPUT, "[%d] %s returned ", vm->depth, IDENT_NAME(id));
    value_print(res, TRACE_OUTPUT);
    fputc('\n', TRACE_OUTPUT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
xorl %edx, %edx
callq 0x5d56
testq %rax, %rax
je 0x32e2
movq %rax, %r15
movq %r14, %rdi
callq 0x32ee
movq 0x7d2b(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movl (%r14), %edx
movq (%r15), %rcx
leaq 0x3fbc(%rip), %rsi      # 0x7272
xorl %eax, %eax
callq 0x20d0
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2755
movq (%r12), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/prims.c
// Function: bcf_print
void bcf_print(ins_t *ins)
{
    ins_push(ins, bc_args_new(1));
    ins_push(ins, bc_ref_new(0, 0, NULL));
    ins_push(ins, bc_print_new());
    ins_push(ins, bc_return_new());
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
callq 0x45dd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4798
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
callq 0x476b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
callq 0x47c4
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x61d6
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/prims.c
// Function: elo_extend_env
env_t *elo_extend_env(env_t *env)
{
    for (int i = 0; i < prims_num; i++) {
        prim_t *p = &prims[i];
        value_t *f = NULL;
        if (p->is_compiled) {
            ins_t *code = ins_new();
            ((bcf_t)p->func_ptr)(code);
            f = value_ucf_new(p->arity, code);
        } else {
            f = value_bif_new(p->func_ptr, p->arity);
        }
        env_set(env, p->name, f);
    }
    return env;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x7bf0(%rip)      # 0xb300
je 0x376a
leaq 0x79ff(%rip), %r15      # 0xb118
xorl %r12d, %r12d
cmpl $0x0, -0x18(%r15)
je 0x373f
callq 0x61aa
movq %rax, %r14
movq %rax, %rdi
callq *-0x8(%r15)
movl (%r15), %edi
movq %r14, %rsi
callq 0x26dd
jmp 0x374b
movq -0x8(%r15), %rdi
movl (%r15), %esi
callq 0x24f0
movq -0x10(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x55ee
incq %r12
addq $0x20, %r15
cmpq %r12, 0x7b98(%rip)      # 0xb300
ja 0x371c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: interp_new
interp_t *interp_new(void)
{
    interp_t *i = malloc(sizeof(interp_t));
    i->depth = 0;
    i->env = env_new(env_empty_new());
    i->syntax_env = hash_table_new(hash_str, comp_str);
    i->traced_objs = hash_table_new(hash_ptr, comp_ptr);
    i->denv = env_new(env_empty_new());
    interp_initbif(i);
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x28, %edi
callq 0x20e0
movq %rax, %rbx
movl $0x0, (%rax)
callq 0x5568
movq %rax, %rdi
callq 0x556b
movq %rax, %r15
movq %rax, 0x18(%rbx)
leaq 0x2610(%rip), %rdi      # 0x5dc5
leaq 0x2637(%rip), %rsi      # 0x5df3
callq 0x5c70
movq %rax, %r14
movq %rax, 0x8(%rbx)
leaq 0x25f2(%rip), %rdi      # 0x5dc1
leaq 0x2614(%rip), %rsi      # 0x5dea
callq 0x5c70
movq %rax, 0x10(%rbx)
callq 0x5568
movq %rax, %rdi
callq 0x556b
movq %rbx, (%rsp)
movq %rax, 0x20(%rbx)
leaq 0x7b05(%rip), %r13      # 0xb300
movq (%r13), %rax
testq %rax, %rax
je 0x3845
leaq 0x78f5(%rip), %rbp      # 0xb100
addq $0x18, %rbp
xorl %ebx, %ebx
cmpl $0x0, -0x18(%rbp)
jne 0x3839
movq -0x10(%rbp), %r12
movq -0x8(%rbp), %rdi
movl (%rbp), %esi
callq 0x24f0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x55ee
movq (%r13), %rax
incq %rbx
addq $0x20, %rbp
cmpq %rbx, %rax
ja 0x3811
movl $0x8, %edi
callq 0x20e0
leaq 0x2f9(%rip), %rcx       # 0x3b4f
movq %rcx, (%rax)
leaq 0x3b4f(%rip), %rsi      # 0x73af
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x385(%rip), %rcx       # 0x3c01
movq %rcx, (%rax)
leaq 0x3b18(%rip), %rsi      # 0x739e
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x3d9(%rip), %rcx       # 0x3c7b
movq %rcx, (%rax)
leaq 0x3af5(%rip), %rsi      # 0x73a1
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x426(%rip), %rcx       # 0x3cee
movq %rcx, (%rax)
leaq 0x3ad5(%rip), %rsi      # 0x73a7
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x445(%rip), %rcx       # 0x3d33
movq %rcx, (%rax)
leaq 0x3ab6(%rip), %rsi      # 0x73ae
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x47e(%rip), %rcx       # 0x3d92
movq %rcx, (%rax)
leaq 0x3a95(%rip), %rsi      # 0x73b3
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x4bd(%rip), %rcx       # 0x3df7
movq %rcx, (%rax)
leaq 0x3a74(%rip), %rsi      # 0x73b8
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x4fb(%rip), %rcx       # 0x3e5b
movq %rcx, (%rax)
leaq 0x3a55(%rip), %rsi      # 0x73bf
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x53d(%rip), %rcx       # 0x3ec3
movq %rcx, (%rax)
leaq 0x3a31(%rip), %rsi      # 0x73c1
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movl $0x8, %edi
callq 0x20e0
leaq 0x5a0(%rip), %rcx       # 0x3f4c
movq %rcx, (%rax)
leaq 0x3a11(%rip), %rsi      # 0x73c7
movq %r14, %rdi
movq %rax, %rdx
callq 0x5cd0
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: interp_execute
value_kind_t interp_execute(interp_t *interp, ast_t *ast, value_t **value)
{
    switch (ast->kind) {
        case AST_CONS:
            return interp_execute_cons(interp, ast, value);
        case AST_END_OF_CONS:
            if (value != NULL)
                *value = value_int_new(0);
            return VALUE_INT;
        case AST_IDENTIFIER:
            return interp_execute_ident(interp, ast, value);
        case AST_INTEGER:
            if (value != NULL)
                *value = value_int_new(AST_INT_VALUE(ast));
            return VALUE_INT;
        default :
            fprintf(stderr, "Don't know how to execute: %d", ast->kind);
            exit(1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movl (%rsi), %edi
leal -0x1(%rdi), %eax
cmpl $0x4, %eax
ja 0x3b4a
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x396e(%rip), %rcx      # 0x736c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %r12
cmpl $0x4, (%r12)
jne 0x3a90
movq 0x10(%r12), %rax
movq (%rax), %rsi
movq 0x8(%r15), %rdi
xorl %edx, %edx
callq 0x5d56
testq %rax, %rax
je 0x3ae7
movq 0x18(%r14), %rsi
movq (%rax), %rax
movq %r15, %rdi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq 0x18(%r15), %rdi
movq 0x10(%r14), %rax
movq (%rax), %r15
movq %r15, %rsi
callq 0x574b
testq %rax, %rax
je 0x3ab2
testq %rbx, %rbx
je 0x3a69
movq %rax, (%rbx)
movl (%rax), %ebp
jmp 0x3ad8
movl $0x5, %ebp
testq %rbx, %rbx
je 0x3ad8
movl 0x10(%r14), %edi
jmp 0x3a89
movl $0x5, %ebp
testq %rbx, %rbx
je 0x3ad8
xorl %edi, %edi
callq 0x267a
jmp 0x3ad5
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3ad8
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x39b6(%rip), %rdi      # 0x745f
xorl %eax, %eax
callq 0x2596
jmp 0x3ad5
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3ad8
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x3902(%rip), %rdi      # 0x73cd
movq %r15, %rcx
xorl %eax, %eax
callq 0x2596
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x39d4
cmpl $0x4, %eax
je 0x3b19
movl $0x2, %ebp
cmpl $0x2, %eax
jne 0x3b31
testq %rbx, %rbx
je 0x3ad8
movq 0x8(%rsp), %rax
jmp 0x3ad5
movq 0x8(%rsp), %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x3fea
movl %eax, %ebp
jmp 0x3ad8
testq %rbx, %rbx
je 0x3ad8
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x3953(%rip), %rdi      # 0x7498
jmp 0x3aa9
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_set
static value_kind_t bis_set(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *var = AST_CONS_CAR(body);
    ast_t *expr = AST_CONS_CAR( AST_CONS_CDR(body) );
    value_t *val = NULL;
    if (interp_execute(interp, expr, &val) == VALUE_ERROR) {
        if (result != NULL)
            *result = val;
        return val->kind;
    }

    if (is_valof_form(var)) {
        value_t *ref = NULL;
        if (interp_execute(interp, AST_CONS_CADR(var), &ref) == VALUE_ERROR) {
            if (result != NULL)
                *result = ref;
            return elo_type(ref);
        }
        *VALUE_REF_ADDR(ref) = val;
    } else
        interp_set(interp, AST_IDENT_NAME(var), val);
    if (result != NULL)
        *result = val;
    return val->kind;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
callq 0x39d4
cmpl $0x2, %eax
je 0x3bd8
movq %r15, %rdi
callq 0x5a6a
testl %eax, %eax
je 0x3bc3
leaq 0x10(%rsp), %r12
movq $0x0, (%r12)
movq 0x18(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x39d4
movq (%r12), %rcx
cmpl $0x2, %eax
jne 0x3bf3
testq %rbx, %rbx
je 0x3bbf
movq %rcx, (%rbx)
movl (%rcx), %eax
jmp 0x3be7
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x55ee
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x3be5
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%rsp), %rax
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
jmp 0x3bdd
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_if
static value_kind_t bis_if(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *pred = AST_CONS_CAR(body);
    ast_t *p = AST_CONS_CAR( AST_CONS_CDR(body) );
    ast_t *e = AST_CONS_CAR( AST_CONS_CDR( AST_CONS_CDR(body) ) );
    value_t *pred_val = NULL;
    if (interp_execute(interp, pred, &pred_val) == VALUE_ERROR) {
        if (result != NULL)
            *result = pred_val;
        return pred_val->kind;
    }

    if (pred_val->kind == VALUE_INT && VALUE_INT_VALUE(pred_val) == 0) {
        return interp_execute(interp, e, result);
    } else {
        return interp_execute(interp, p, result);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %r15
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %r12
movq %rsp, %rdx
movq $0x0, (%rdx)
movq %rax, %rsi
callq 0x39d4
cmpl $0x2, %eax
jne 0x3c4a
movq (%rsp), %rax
testq %rbx, %rbx
je 0x3c46
movq %rax, (%rbx)
movl (%rax), %eax
jmp 0x3c67
movq (%rsp), %rax
cmpl $0x5, (%rax)
jne 0x3c59
cmpl $0x0, 0x8(%rax)
je 0x3c73
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x39d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r12, %rsi
jmp 0x3c5f
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_begin
static value_kind_t bis_begin(interp_t *interp, ast_t *body, value_t **result)
{
    while (body->kind == AST_CONS && AST_CONS_CDR(body)->kind != AST_END_OF_CONS) {
        ast_t *expr = AST_CONS_CAR(body);
        value_t *v = NULL;
        if (interp_execute(interp, expr, &v) == VALUE_ERROR) {
            if (result != NULL)
                *result = v;
            return v->kind;
        }
        body = AST_CONS_CDR(body);
    }
    return interp_execute(interp, AST_CONS_CAR(body), result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, (%rsi)
jne 0x3cc3
movq %rsp, %r12
movq 0x18(%r15), %rax
cmpl $0x2, (%rax)
je 0x3cc3
movq 0x10(%r15), %rsi
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x39d4
cmpl $0x2, %eax
je 0x3cde
movq 0x18(%r15), %r15
cmpl $0x1, (%r15)
je 0x3c94
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x39d4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rsp), %rax
testq %rbx, %rbx
je 0x3cea
movq %rax, (%rbx)
movl (%rax), %eax
jmp 0x3cd2
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_lambda
static value_kind_t bis_lambda(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *pars = AST_CONS_CAR(body);
    body = AST_CONS_CDR(body);
    value_t *val = value_udf_new(ast_cons_length(pars), pars, body, interp->env);
    if (result != NULL)
        *result = val;
    return val->kind;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r12
movq %r15, %rdi
callq 0x5a2a
movq 0x18(%r14), %rcx
movl %eax, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2711
testq %rbx, %rbx
je 0x3d25
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_dset
static value_kind_t bis_dset(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *var = AST_CONS_CAR(body);
    ast_t *expr = AST_CONS_CAR( AST_CONS_CDR(body) );
    value_t *val = NULL;
    if (interp_execute(interp, expr, &val) == VALUE_ERROR) {
        if (result != NULL)
            *result = val;
        return val->kind;
    }

    env_set(interp->denv, AST_IDENT_NAME(var), val);
    if (result != NULL)
        *result = val;
    return val->kind;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rsi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
callq 0x39d4
cmpl $0x2, %eax
je 0x3d79
movq 0x20(%r14), %rdi
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x55ee
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x3d86
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_dget
static value_kind_t bis_dget(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *var = AST_CONS_CAR(body);
    char *name = AST_IDENT_NAME(var);
    value_t *val = env_get(interp->denv, name);
    if (val != NULL) {
        if (result != NULL)
            *result = val;
        return val->kind;
    } else {
        if (result != NULL)
            *result = value_error_newf("Line %d, column %d: Can't find value of `%s'", var->line, var->column, name);
        return VALUE_ERROR;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rsi), %r15
movq 0x10(%r15), %rax
movq (%rax), %r14
movq 0x20(%rdi), %rdi
movq %r14, %rsi
callq 0x574b
testq %rax, %rax
je 0x3dc4
testq %rbx, %rbx
je 0x3dc0
movq %rax, (%rbx)
movl (%rax), %ebp
jmp 0x3dea
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3dea
movl 0x4(%r15), %esi
movl 0x8(%r15), %edx
leaq 0x35f0(%rip), %rdi      # 0x73cd
movq %r14, %rcx
xorl %eax, %eax
callq 0x2596
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_define
static value_kind_t bis_define(interp_t *interp, ast_t *body, value_t **result)
{
    /* 构造符合set语法的表达式并再次求值 */
    ast_t *name = AST_CONS_CAR(body);
    ast_t *lpart = AST_CONS_CDR(body);
    ast_t *lexpr = ast_cons_new(ast_ident_new("lambda"), lpart);
    ast_t *sexpr = ast_cons_new(name, ast_cons_new(lexpr, ast_eoc_new()));
    return bis_set(interp, sexpr, result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r12
leaq 0x3593(%rip), %rdi      # 0x73a7
callq 0x58cf
movq %rax, %rdi
movq %r12, %rsi
callq 0x587f
movq %rax, %r12
callq 0x58a9
movq %r12, %rdi
movq %rax, %rsi
callq 0x587f
movq %r15, %rdi
movq %rax, %rsi
callq 0x587f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3b4f
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_refof
static value_kind_t bis_refof(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *var = AST_CONS_CAR(body);
    if (var->kind != AST_IDENTIFIER) {
        if (result != NULL)
            *result = value_error_newf("Line %d, column %d: Operand of & must be an identifier", var->line, var->column);
        return VALUE_ERROR;
    }

    value_t **addr = env_getaddr(interp->env, AST_IDENT_NAME(var));
    if (result != NULL)
        *result = value_ref_new(addr);
    return VALUE_REF;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
movq 0x10(%rsi), %rax
cmpl $0x4, (%rax)
jne 0x3e8f
movq 0x18(%rdi), %rdi
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x57fd
testq %rbx, %rbx
je 0x3eb5
movq %rax, %rdi
callq 0x2692
movq %rax, %rcx
movl $0x6, %eax
jmp 0x3eb0
testq %rbx, %rbx
je 0x3ebc
movl 0x4(%rax), %esi
movl 0x8(%rax), %edx
leaq 0x3559(%rip), %rdi      # 0x73fa
xorl %eax, %eax
callq 0x2596
movq %rax, %rcx
movl $0x2, %eax
movq %rcx, (%rbx)
jmp 0x3ec1
movl $0x6, %eax
jmp 0x3ec1
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_valof
static value_kind_t bis_valof(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *expr = AST_CONS_CAR(body);
    value_t *val = NULL;
    if (interp_execute(interp, expr, &val) == VALUE_ERROR) {
        if (result != NULL)
            *result = val;
        return elo_type(val);
    }
    if (elo_type(val) != VALUE_REF) {
        if (result != NULL)
            *result = value_error_newf("Line %d, column %d: Value must be a reference", expr->line, expr->column);
        return VALUE_ERROR;
    }
    if (result != NULL)
        *result = *VALUE_REF_ADDR(val);
    return (*VALUE_REF_ADDR(val))->kind;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq 0x10(%rsi), %r14
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r14, %rsi
callq 0x39d4
cmpl $0x2, %eax
jne 0x3efa
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x3f1a
movq %rax, (%rbx)
jmp 0x3f1a
movq 0x8(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x3f27
testq %rbx, %rbx
je 0x3f13
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3f1c
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x34f1(%rip), %rdi      # 0x7431
xorl %eax, %eax
callq 0x2596
movq %rax, (%rbx)
jmp 0x3f1c
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: bis_trace
static value_kind_t bis_trace(interp_t *interp, ast_t *body, value_t **result)
{
    ast_t *expr = AST_CONS_CAR(body);
    value_t *obj = NULL;
    if (interp_execute(interp, expr, &obj) == VALUE_ERROR) {
        if (result != NULL)
            *result = obj;
        return obj->kind;
    }
    if (elo_type(obj) == VALUE_FUNCTION) {
        ident_t *id = NULL;
        if (expr->kind == AST_IDENTIFIER)
            id = ident_intern(AST_IDENT_NAME(expr));
        else {
            char name[32] = {0};
            snprintf(name, sizeof(name), "#<%p>", obj);
            id = ident_intern(name);
        }
        hash_table_set(interp->traced_objs, obj, id);
    }
    if (result != NULL)
        *result = obj;
    return obj->kind;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq %r15, %rsi
callq 0x39d4
cmpl $0x2, %eax
je 0x3fd1
movq 0x8(%rsp), %rcx
cmpl $0x4, (%rcx)
jne 0x3fd6
cmpl $0x4, (%r15)
jne 0x3f91
movq 0x10(%r15), %rax
movq (%rax), %rdi
jmp 0x3fbb
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x3165(%rip), %rdx      # 0x710e
movl $0x20, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x28f8
movq 0x10(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x5cd0
movq 0x8(%rsp), %rcx
testq %rbx, %rbx
je 0x3fde
movq %rcx, (%rbx)
movl (%rcx), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: interp_trace_callbif
static void interp_trace_callbif(interp_t *interp, value_t *f, ...)
{
    ident_t *id = NULL;
    if (!is_traced(interp, f, &id))
        return;
    interp_trace_space(interp);
    fprintf(TRACE_OUTPUT, "[%d] ", interp->depth);
    fprintf(TRACE_OUTPUT, "%s", IDENT_NAME(id));
    fputc('(', TRACE_OUTPUT);
    va_list ap;
    va_start(ap, f);
    value_t *arg = va_arg(ap, value_t *);
    while (arg != NULL) {
        value_print(arg, TRACE_OUTPUT);
        arg = va_arg(ap, value_t *);
        if (arg != NULL)
            fprintf(TRACE_OUTPUT, ", ");
    }
    fprintf(TRACE_OUTPUT, ")\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x43a1
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x10(%rdi), %rdi
xorl %edx, %edx
callq 0x5d56
testq %rax, %rax
je 0x44bb
movq %rax, %r14
movq %rbx, %rdi
callq 0x4564
movq 0x6c09(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movl (%rbx), %edx
leaq 0x317f(%rip), %rsi      # 0x7552
xorl %eax, %eax
callq 0x20d0
movq (%r15), %rsi
movq (%r14), %rdi
callq 0x2070
movq (%r15), %rsi
movl $0x28, %edi
callq 0x20a0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x4434
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x4442
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x44a2
leaq 0x2e18(%rip), %rbx      # 0x7269
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2755
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x4475
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x4483
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x44a2
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2140
jmp 0x4451
movq (%r15), %rcx
leaq 0x2dc0(%rip), %rdi      # 0x726c
movl $0x2, %esi
movl $0x1, %edx
callq 0x2140
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/interp.c
// Function: interp_trace_retbif
static void interp_trace_retbif(interp_t *interp, value_t *f, value_t *res)
{
    ident_t *id = NULL;
    if (!is_traced(interp, f, &id))
        return;
    interp_trace_space(interp);
    fprintf(TRACE_OUTPUT, "[%d] ", interp->depth);
    fprintf(TRACE_OUTPUT, "%s", IDENT_NAME(id));
    fprintf(TRACE_OUTPUT, " returned ");
    value_print(res, TRACE_OUTPUT);
    fputc('\n', TRACE_OUTPUT);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
xorl %edx, %edx
callq 0x5d56
testq %rax, %rax
je 0x4558
movq %rax, %r14
movq %r15, %rdi
callq 0x4564
movq 0x6ad8(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movl (%r15), %edx
leaq 0x304c(%rip), %rsi      # 0x7552
xorl %eax, %eax
callq 0x20d0
movq (%r12), %rsi
movq (%r14), %rdi
callq 0x2070
movq (%r12), %rcx
leaq 0x2d55(%rip), %rdi      # 0x7279
movl $0xa, %esi
movl $0x1, %edx
callq 0x2140
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2755
movq (%r12), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/bytecode.c
// Function: bc_print
void bc_print(bytecode_t *bc, FILE *output)
{
    fprintf(output, "%s", bc_name(bc));
    switch (BC_OPCODE(bc)) {
        case BC_ADDR:
            fprintf(output, " %s", BC_ADDR_NAME(bc));
            break;
        case BC_ARGS:
            fprintf(output, " %d", BC_ARGS_ARITY(bc));
            break;
        case BC_CALL:
            fprintf(output, " %d", BC_CALL_NARGS(bc));
            break;
        case BC_DGET:
            fprintf(output, " %s", BC_DGET_NAME(bc));
            break;
        case BC_DSET:
            fprintf(output, " %s", BC_DSET_NAME(bc));
            break;
        case BC_FJUMP:
            fprintf(output, " %d", BC_FJUMP_INDEX(bc));
            break;
        case BC_JUMP:
            fprintf(output, " %d", BC_JUMP_INDEX(bc));
            break;
        case BC_LABEL:
            fprintf(output, " %s", BC_LABEL_NAME(bc));
            break;
        case BC_PUSH:
            fputc(' ', output);
            value_print(BC_PUSH_PTR(bc), output);
            break;
        case BC_GREF:
        case BC_REF:
            fprintf(output, " %d %d ; %s", BC_REF_I(bc), BC_REF_J(bc), BC_REF_NAME(bc));
            break;
        case BC_GSET:
        case BC_SET:
            fprintf(output, " %d %d ; %s", BC_SET_I(bc), BC_SET_J(bc), BC_SET_NAME(bc));
            break;
        case BC_TRACE:
            fprintf(output, " %s", BC_TRACE_NAME(bc));
            break;
        default :
            break;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
leaq 0x64ed(%rip), %rcx      # 0xad30
movq (%rcx,%rax,8), %rdi
callq 0x2070
movl (%r14), %eax
cmpq $0x14, %rax
ja 0x48f4
leaq 0x2cf8(%rip), %rcx      # 0x7558
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq 0x10(%r14), %r8
leaq 0x2d30(%rip), %rsi      # 0x75ac
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movq 0x8(%r14), %rax
movq (%rax), %rdx
jmp 0x48a0
movl 0x8(%r14), %edx
jmp 0x48bc
movq 0x8(%r14), %rdx
leaq 0x2825(%rip), %rsi      # 0x70cc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl 0x10(%r14), %edx
leaq 0x2e83(%rip), %rsi      # 0x7746
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl $0x20, %edi
movq %rbx, %rsi
callq 0x20a0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2755
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/bytecode.c
// Function: ins_pretty_print
void ins_pretty_print(ins_t *ins, FILE *output, int indent)
{
    int i = 0;
    while (i < ins_length(ins)) {
        bytecode_t *bc = ins_ref(ins, i);
        assert(BC_OPCODE(bc) != BC_LABEL);
        if (BC_OPCODE(bc) != BC_PUSH) {
            ins_indent_print(indent, i, output);
            bc_print(bc, output);
        } else
            ins_push_print(bc, output, indent, i);
        fputc('\n', output);
        i++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x49f3
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rbx), %eax
movl %eax, 0x4(%rsp)
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x629b
movq %rax, %r13
movl (%rax), %eax
cmpl $0x10, %eax
je 0x4951
cmpl $0xc, %eax
jne 0x49c1
jmp 0x4a02
movq 0x8(%r13), %rbp
cmpl $0x4, (%rbp)
jne 0x49c1
cmpl $0x0, 0xc(%rbp)
je 0x49c1
movl %ebx, %edi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4a21
movl $0x20, %esi
movl $0x1, %edx
leaq 0x2c8f(%rip), %rdi      # 0x760e
movq %r14, %rcx
callq 0x2140
movq 0x20(%rbp), %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x490a
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x4a21
movl $0x9, %esi
movl $0x1, %edx
leaq 0x2c78(%rip), %rdi      # 0x762f
movq %r14, %rcx
callq 0x2140
jmp 0x49d9
movl %ebx, %edi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4a21
movq %r13, %rdi
movq %r14, %rsi
callq 0x4830
movl $0xa, %edi
movq %r14, %rsi
callq 0x20a0
incq %r12
cmpq %r12, 0x10(%r15)
ja 0x4932
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2baf(%rip), %rdi      # 0x75b8
leaq 0x2bc2(%rip), %rsi      # 0x75d2
leaq 0x2bc6(%rip), %rcx      # 0x75dd
movl $0x106, %edx            # imm = 0x106
callq 0x2060
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/bytecode.c
// Function: ins_indent_print
static void ins_indent_print(int indent, int index, FILE *output)
{
    int prefix = indent - 1;
    while (prefix >= 0) {
        fputc('\t', output);
        prefix--;
    }
    if (index != -1)
        fprintf(output, "[%d]", index);
    fputc('\t', output);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
testl %edi, %edi
jle 0x4a4a
movl %edi, %r14d
incl %r14d
movl $0x9, %edi
movq %rbx, %rsi
callq 0x20a0
decl %r14d
cmpl $0x1, %r14d
ja 0x4a34
cmpl $-0x1, %ebp
je 0x4a62
leaq 0x2bb3(%rip), %rsi      # 0x7609
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x20d0
movl $0x9, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x20a0
nop
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_new
compiler_t *compiler_new(void)
{
    compiler_t *c = malloc(sizeof(compiler_t));
    c->error = string_new();
    /* Environment */
    c->env = env_new(env_empty_new());
    c->init_env = elo_extend_env(env_new(env_empty_new()));
    c->global_env = c->init_env;

    c->label_table = hash_table_new(hash_str, comp_str);
    c->rts = hash_table_new(hash_str, comp_str);
    compiler_setrt(c, "begin", compiler_do_begin);
    compiler_setrt(c, "set", compiler_do_set);
    compiler_setrt(c, "if", compiler_do_if);
    compiler_setrt(c, "lambda", compiler_do_lambda);
    compiler_setrt(c, "dget", compiler_do_dget);
    compiler_setrt(c, "dset", compiler_do_dset);
    compiler_setrt(c, "define", compiler_do_define);
    compiler_setrt(c, "&", compiler_do_refof);
    compiler_setrt(c, "valof", compiler_do_valof);
    compiler_setrt(c, "trace", compiler_do_trace);
    c->counter = 0;
    return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x38, %edi
callq 0x20e0
movq %rax, %rbx
callq 0x5fdf
movq %rax, 0x30(%rbx)
callq 0x5568
movq %rax, %rdi
callq 0x556b
movq %rax, 0x8(%rbx)
callq 0x5568
movq %rax, %rdi
callq 0x556b
movq %rax, %rdi
callq 0x36fd
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x1301(%rip), %r14      # 0x5dc5
leaq 0x1328(%rip), %r15      # 0x5df3
movq %r14, %rdi
movq %r15, %rsi
callq 0x5c70
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5c70
movq %rax, %r14
movq %rax, 0x28(%rbx)
leaq 0x28ae(%rip), %rsi      # 0x73a1
leaq 0xdd(%rip), %rdx        # 0x4bd7
movq %rax, %rdi
callq 0x5cd0
leaq 0x28a6(%rip), %rsi      # 0x73af
leaq 0x12c(%rip), %rdx       # 0x4c3c
movq %r14, %rdi
callq 0x5cd0
leaq 0x287f(%rip), %rsi      # 0x739e
leaq 0x241(%rip), %rdx       # 0x4d67
movq %r14, %rdi
callq 0x5cd0
leaq 0x2872(%rip), %rsi      # 0x73a7
leaq 0x303(%rip), %rdx       # 0x4e3f
movq %r14, %rdi
callq 0x5cd0
leaq 0x2868(%rip), %rsi      # 0x73b3
leaq 0x3e8(%rip), %rdx       # 0x4f3a
movq %r14, %rdi
callq 0x5cd0
leaq 0x284d(%rip), %rsi      # 0x73ae
leaq 0x3f8(%rip), %rdx       # 0x4f60
movq %r14, %rdi
callq 0x5cd0
leaq 0x2841(%rip), %rsi      # 0x73b8
leaq 0x426(%rip), %rdx       # 0x4fa4
movq %r14, %rdi
callq 0x5cd0
leaq 0x2832(%rip), %rsi      # 0x73bf
leaq 0x474(%rip), %rdx       # 0x5008
movq %r14, %rdi
callq 0x5cd0
leaq 0x281e(%rip), %rsi      # 0x73c1
leaq 0x4a7(%rip), %rdx       # 0x5051
movq %r14, %rdi
callq 0x5cd0
leaq 0x280e(%rip), %rsi      # 0x73c7
leaq 0x4bd(%rip), %rdx       # 0x507d
movq %r14, %rdi
callq 0x5cd0
movl $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_begin
static int compiler_do_begin(compiler_t *comp, ast_t *body, ins_t *ins)
{
    while (body->kind == AST_CONS && AST_CONS_CDR(body)->kind != AST_END_OF_CONS) {
        ast_t *expr = AST_CONS_CAR(body);
        if (compiler_do(comp, expr, ins) == ERR)
            return ERR;
        ins_push(ins, bc_pop_new());
        body = AST_CONS_CDR(body);
    }
    return compiler_do(comp, AST_CONS_CAR(body), ins);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpl $0x1, (%rsi)
jne 0x4c20
movq 0x18(%r15), %rax
cmpl $0x2, (%rax)
je 0x4c20
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x50ed
testl %eax, %eax
je 0x4c34
callq 0x4758
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movq 0x18(%r15), %r15
cmpl $0x1, (%r15)
je 0x4bea
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x50ed
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_set
static int compiler_do_set(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *var = AST_CONS_CAR(body);
    ast_t *expr = AST_CONS_CAR( AST_CONS_CDR(body) );
    if (is_valof_form(var)) {
        if (compiler_do(comp, expr, ins) == ERR)
            return ERR;
        if (compiler_do(comp, AST_CONS_CADR(var), ins) == ERR)
            return ERR;
        ins_push(ins, bc_aset_new());
        return OK;
    }

    bytecode_t *bc = NULL;
    int i = 0, j = 0;
    char *name = AST_IDENT_NAME(var);
    if (env_locate(comp->env, name, &i, &j) == OK) {
        /* In the current lexical environment */
        bc = bc_set_new(i, j, name);
    } else if (env_locate(comp->global_env, name, &i, &j) == OK) {
        /* In the global environment */
        bc = bc_gset_new(i, j, name);
    } else {
        /* Define in current lexical environment */
        env_push(comp->env, name, NULL, NULL, NULL);
        bc = bc_set_new(-1, -1, name);
    }
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ins_push(ins, bc);
    return OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r12
movq 0x18(%rsi), %rax
movq 0x10(%rax), %r15
movq %r12, %rdi
callq 0x5a6a
testl %eax, %eax
je 0x4caa
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x50ed
xorl %ebp, %ebp
testl %eax, %eax
je 0x4d58
movq 0x18(%r12), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x50ed
testl %eax, %eax
je 0x4d58
callq 0x45f5
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x4d4a
xorl %eax, %eax
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movq 0x10(%r12), %rax
movq (%rax), %r12
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x5671
cmpl $0x1, %eax
jne 0x4cdd
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
jmp 0x4d27
movq 0x10(%r14), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %r12, %rsi
callq 0x5671
cmpl $0x1, %eax
jne 0x4d0a
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq %r12, %rdx
callq 0x46c7
jmp 0x4d2f
movq 0x8(%r14), %rdi
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x55a8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r12, %rdx
callq 0x47d7
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x50ed
testl %eax, %eax
je 0x4d56
movq %rbx, %rdi
movq %r12, %rsi
callq 0x61d6
movl $0x1, %ebp
jmp 0x4d58
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_if
static int compiler_do_if(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *pred = AST_CONS_CAR(body);
    ast_t *p = AST_CONS_CAR( AST_CONS_CDR(body) );
    ast_t *e = AST_CONS_CAR( AST_CONS_CDR( AST_CONS_CDR(body) ) );
    if (compiler_do(comp, pred, ins) == ERR)
        return ERR;
    bytecode_t *label_else = compiler_mklabel(comp);
    bytecode_t *label_end = compiler_mklabel(comp);
    ins_push(ins, bc_fjump_new(label_else));
    if (compiler_do(comp, p, ins) == ERR)
        return ERR;
    ins_push(ins, bc_jump_new(label_end));
    ins_push(ins, label_else);
    if (compiler_do(comp, e, ins) == ERR)
        return ERR;
    ins_push(ins, label_end);
    ins_push(ins, bc_nope_new());
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq 0x10(%rcx), %r15
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %r12
movq %rax, %rsi
callq 0x50ed
xorl %ebp, %ebp
testl %eax, %eax
je 0x4e2e
movq %r12, (%rsp)
movq %r14, %rdi
callq 0x53b0
movq %rax, %r13
movq %r14, %rdi
callq 0x53b0
movq %rax, %r12
movq %r13, %rdi
callq 0x4667
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x50ed
testl %eax, %eax
je 0x4e2e
movq %r12, %rdi
callq 0x46f3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movq %rbx, %rdi
movq %r13, %rsi
callq 0x61d6
movq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x50ed
testl %eax, %eax
je 0x4e2e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x61d6
callq 0x4745
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_lambda
static int compiler_do_lambda(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *pars = AST_CONS_CAR(body);
    body = AST_CONS_CDR(body);
    int arity = compiler_extend_scope(comp, pars);
    ins_t *code = ins_new();
    ins_push(code, bc_args_new(arity));
    if (compiler_do_begin(comp, body, code) == ERR) {
        compiler_exit_scope(comp);
        return ERR;
    }
    ins_push(code, bc_return_new());
    compiler_exit_scope(comp);
    code = compiler_assemby(comp, code);
    value_t *f = value_ucf_new(arity, code);
    ins_push(ins, bc_push_new(f));
    ins_push(ins, bc_func_new());
    return OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %r12
movq 0x8(%rdi), %rdi
callq 0x556b
movq %rax, 0x8(%r14)
xorl %r15d, %r15d
cmpl $0x1, (%r13)
jne 0x4e99
xorl %r15d, %r15d
movq 0x10(%r13), %rax
movq 0x8(%r14), %rdi
movq 0x10(%rax), %rax
movq (%rax), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x55a8
movq 0x18(%r13), %r13
incl %r15d
cmpl $0x1, (%r13)
je 0x4e70
callq 0x61aa
movq %rax, %r13
movl %r15d, %edi
callq 0x45dd
movq %r13, %rdi
movq %rax, %rsi
callq 0x61d6
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4bd7
testl %eax, %eax
je 0x4f22
callq 0x47c4
movq %r13, %rdi
movq %rax, %rsi
callq 0x61d6
movq 0x8(%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
movq %r13, %rsi
callq 0x52f2
movl %r15d, %edi
movq %rax, %rsi
callq 0x26dd
movq %rax, %rdi
callq 0x477e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
callq 0x4688
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movl $0x1, %eax
jmp 0x4f30
movq 0x8(%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_dset
static int compiler_do_dset(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *var = AST_CONS_CAR(body);
    ast_t *expr = AST_CONS_CAR( AST_CONS_CDR(body) );
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ins_push(ins, bc_dset_new(AST_IDENT_NAME(var)));
    return OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rsi), %r14
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rsi
callq 0x50ed
testl %eax, %eax
je 0x4f9a
movq 0x10(%r14), %rax
movq (%rax), %rdi
callq 0x464d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movl $0x1, %eax
jmp 0x4f9c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_define
static int compiler_do_define(compiler_t *comp, ast_t *body, ins_t *ins)
{
    /* 构造符合set语法的表达式并再次编译 */
    ast_t *name = AST_CONS_CAR(body);
    ast_t *lpart = AST_CONS_CDR(body);
    ast_t *lexpr = ast_cons_new(ast_ident_new("lambda"), lpart);
    ast_t *sexpr = ast_cons_new(name, ast_cons_new(lexpr, ast_eoc_new()));
    return compiler_do_set(comp, sexpr, ins);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r12
leaq 0x23e6(%rip), %rdi      # 0x73a7
callq 0x58cf
movq %rax, %rdi
movq %r12, %rsi
callq 0x587f
movq %rax, %r12
callq 0x58a9
movq %r12, %rdi
movq %rax, %rsi
callq 0x587f
movq %r15, %rdi
movq %rax, %rsi
callq 0x587f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4c3c
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_refof
static int compiler_do_refof(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *var = AST_CONS_CAR(body);
    if (var->kind != AST_IDENTIFIER) {
        string_printf(comp->error, "Line %d, column %d: Operand of & must be an identifier", var->line, var->column);
        return ERR;
    }
    ins_push(ins, bc_addr_new(AST_IDENT_NAME(var)));
    return OK;
}

// Assembly:
pushq %rbx
movq 0x10(%rsi), %rax
cmpl $0x4, (%rax)
jne 0x5033
movq %rdx, %rbx
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x45ac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movl $0x1, %ebx
jmp 0x504d
movq 0x30(%rdi), %rdi
movl 0x4(%rax), %edx
movl 0x8(%rax), %ecx
leaq 0x23b6(%rip), %rsi      # 0x73fa
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x60c0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_trace
static int compiler_do_trace(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *expr = AST_CONS_CAR(body);
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ident_t *id = NULL;
    if (expr->kind == AST_IDENTIFIER)
        id = ident_intern(AST_IDENT_NAME(expr));
    ins_push(ins, bc_trace_new(id));
    return OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rsi), %r14
movq %r14, %rsi
callq 0x50ed
testl %eax, %eax
je 0x50ab
cmpl $0x4, (%r14)
jne 0x50af
movq 0x10(%r14), %rax
movq (%rax), %rdi
callq 0x28f8
movq %rax, %rdi
jmp 0x50b1
xorl %eax, %eax
jmp 0x50c6
xorl %edi, %edi
callq 0x4803
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movl (%rdi), %ecx
leaq 0x2378(%rip), %rdx      # 0x774a
movl $0x20, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x4714
incl (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x5af9
cmpl $0x5, %eax
ja 0x54b7
movl %eax, %eax
leaq 0x2363(%rip), %rcx      # 0x7794
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %ebx, %ebx
testq %r14, %r14
je 0x54af
callq 0x586c
movq %rax, (%r14)
jmp 0x54af
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x54be
movl $0x4, %ebx
testq %r14, %r14
je 0x54af
movq (%r15), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x58cf
jmp 0x5493
movl $0x5, %ebx
testq %r14, %r14
je 0x54af
movq (%r15), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2120
movl %eax, %edi
callq 0x5908
movq %rax, (%r14)
movq (%r15), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x4(%rax)
jmp 0x54af
movl $0x3, %ebx
jmp 0x54af
movl $0x6, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x2203