LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/cv_main.c
// Function: main
int main(int argc, char *argv[])
{
    lexer_t *lexer = lexer_new(stdin);
    parser_t *parser = parser_new(lexer);
    compiler_t *comp = compiler_new();
    vm_t *vm = vm_new();
    ast_t *ast = NULL;
    ast_kind_t kind = prompt(parser, &ast);
    while (kind != AST_INVALID) {
        if (kind == AST_END_OF_FILE)
            break;
        fprintf(stdout, "AST > ");
        fflush(stdout);
        ast_print(ast, stdout);
        fputc('\n', stdout);

        ins_t *ins = ins_new();
        if (compiler_do(comp, ast, ins) == 1) {
            fprintf(stdout, "BYTECODE >\n");
            ins_pretty_print(ins, stdout, 0);

            fprintf(stdout, "VM >\n");
            vm_execute(vm, ins);

            ins = ins_new();
            vm_inject_print(ins);
            vm_execute(vm, ins);
        } else
            fprintf(stdout, "Compiler error: %s\n", comp->error->text);
        kind = prompt(parser, &ast);
    }
    fputc('\n', stdout);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8c8a(%rip), %rax      # 0xafd8
movq (%rax), %rdi
callq 0x5b8c
movq %rax, %rdi
callq 0x5478
movq %rax, %rbx
callq 0x4aec
movq %rax, %r14
callq 0x297c
movq %rax, %r15
movq %rsp, %r12
movq $0x0, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24aa
movq 0x8c42(%rip), %r13      # 0xafd0
testl %eax, %eax
je 0x248b
cmpl $0x3, %eax
je 0x248b
movq (%r13), %rcx
movl $0x6, %esi
movl $0x1, %edx
leaq 0x4c50(%rip), %rdi      # 0x7004
callq 0x2140
movq (%r13), %rdi
callq 0x20f0
movq (%rsp), %rdi
movq (%r13), %rsi
callq 0x5a3a
movq (%r13), %rsi
movl $0xa, %edi
callq 0x20a0
callq 0x6282
movq %rax, %rbp
movq (%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x5172
movq (%r13), %rcx
cmpl $0x1, %eax
jne 0x2463
movl $0xb, %esi
movl $0x1, %edx
leaq 0x4bfd(%rip), %rdi      # 0x700b
callq 0x2140
movq (%r13), %rsi
movq %rbp, %rdi
xorl %edx, %edx
callq 0x4982
movq (%r13), %rcx
movl $0x5, %esi
movl $0x1, %edx
leaq 0x4be1(%rip), %rdi      # 0x7017
callq 0x2140
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2a2f
callq 0x6282
movq %rax, %rbp
movq %rax, %rdi
callq 0x30bd
movq %r15, %rdi
movq %rbp, %rsi
callq 0x2a2f
jmp 0x247b
movq 0x30(%r14), %rax
movq (%rax), %rdx
movq %rcx, %rdi
leaq 0x4ba9(%rip), %rsi      # 0x701d
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24aa
jmp 0x238e
movq (%r13), %rsi
movl $0xa, %edi
callq 0x20a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_bif_new
value_t *value_bif_new(void *bif_ptr, unsigned int arity)
{
    value_t *v = value_alloc(VALUE_FUNCTION);
    VALUE_FUNC_ARITY(v) = arity;
    VALUE_FUNC_ISBIF(v) = 1;
    VALUE_FUNC_ISCMP(v) = 0;
    VALUE_BIF_PTR(v) = bif_ptr;
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl $0x30, %edi
callq 0x20e0
movl $0x4, (%rax)
movl %ebx, 0x10(%rax)
movq $0x1, 0x8(%rax)
movq %r14, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_cons_new
value_t *value_cons_new(value_t *car, value_t *cdr)
{
    value_t *v = value_alloc(VALUE_CONS);
    VALUE_CONS_CAR(v) = car;
    VALUE_CONS_CDR(v) = cdr;
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x20e0
movl $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_error_new
value_t *value_error_new(const char *msg)
{
    value_t *v = value_alloc(VALUE_ERROR);
    v->u.err_val.msg = string_new();
    string_assign(v->u.err_val.msg, msg);
    return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %edi
callq 0x20e0
movq %rax, %r14
movl $0x2, (%rax)
callq 0x60b7
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6142
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_error_newf
value_t *value_error_newf(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    char msg[256] = {0};
    vsnprintf(msg, sizeof(msg), fmt, ap);
    return value_error_new(msg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x25f9
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 %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x1f0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
leaq 0xd0(%rsp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x2080
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x2040
movq %r15, %rdi
callq 0x255d
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_ucf_new
value_t *value_ucf_new(int arity, ins_t *code)
{
    value_t *v = value_alloc(VALUE_FUNCTION);
    VALUE_FUNC_ARITY(v) = arity;
    VALUE_FUNC_ISBIF(v) = 0;
    VALUE_FUNC_ISCMP(v) = 1;
    VALUE_UCF_CODE(v) = code;
    return v;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x30, %edi
callq 0x20e0
movl $0x4, (%rax)
movl %ebp, 0x10(%rax)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x8(%rax)
movq %rbx, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_udf_new
value_t *value_udf_new(int arity, ast_t *pars, ast_t *body, env_t *env)
{
    value_t *v = value_alloc(VALUE_FUNCTION);
    VALUE_FUNC_ARITY(v) = arity;
    VALUE_FUNC_ISBIF(v) = 0;
    VALUE_FUNC_ISCMP(v) = 0;
    VALUE_FUNC_ENV(v) = env;
    VALUE_UDF_PARS(v) = pars;
    VALUE_UDF_BODY(v) = body;
    return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x30, %edi
callq 0x20e0
movl $0x4, (%rax)
movl %ebp, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/value.c
// Function: value_print
void value_print(value_t *v, FILE *output)
{
    switch (v->kind) {
        case VALUE_CONS:
            value_print_cons(v, output);
            break;
        case VALUE_END_OF_CONS:
            fprintf(output, "()");
            break;
        case VALUE_ERROR:
            fprintf(output, "ERROR: %s", VALUE_ERR_MSG(v));
            break;
        case VALUE_FLOAT:
            fprintf(output, "%f", VALUE_FLOAT_VALUE(v));
            break;
        case VALUE_FUNCTION:
            value_function_print(v, output);
            break;
        case VALUE_INT:
            fprintf(output, "%d", v->u.int_val);
            break;
        case VALUE_REF:
            fprintf(output, "#<REF %p>", VALUE_REF_ADDR(v));
            break;
        case VALUE_TYPE:
            fprintf(output, "#<TYPE %s>", IDENT_NAME( VALUE_TYPE_NAME(v) ));
            break;
        default :
            fprintf(stderr, "Don't know how to print value: %d", v->kind);
            exit(1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rdi), %edi
cmpq $0x7, %rdi
ja 0x28dc
movq %rsi, %rbx
leaq 0x48cd(%rip), %rax      # 0x7040
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%r14), %r15
movq 0x10(%r14), %r14
movl $0x28, %edi
movq %rbx, %rsi
callq 0x20a0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2755
cmpl $0x1, (%r14)
je 0x27c6
leaq 0x4961(%rip), %rdi      # 0x710a
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2755
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20a0
cmpl $0x0, 0x8(%r14)
je 0x287e
movq 0x20(%r14), %rdx
leaq 0x4920(%rip), %rsi      # 0x710e
jmp 0x286f
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x48c8(%rip), %rsi      # 0x70c6
jmp 0x286f
movsd 0x8(%r14), %xmm0
leaq 0x48c3(%rip), %rsi      # 0x70d0
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x48b3(%rip), %rsi      # 0x70dd
jmp 0x286f
leaq 0x4890(%rip), %rdi      # 0x70c3
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2140
movl 0x8(%r14), %edx
leaq 0x4ef2(%rip), %rsi      # 0x7747
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
movq 0x8(%r14), %rdx
leaq 0x4864(%rip), %rsi      # 0x70d3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
cmpl $0x0, 0xc(%r14)
je 0x2894
leaq 0x4882(%rip), %rsi      # 0x710e
movq %rbx, %rdi
movq %r14, %rdx
jmp 0x2872
leaq 0x4879(%rip), %rdi      # 0x7114
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2140
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x5a3a
movl $0x20, %edi
movq %rbx, %rsi
callq 0x20a0
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x5a3a
movl $0x3e, %edi
jmp 0x27cb
callq 0x2170
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/ident.c
// Function: ident_intern
ident_t *ident_intern(const char *name)
{
    if (ident_table == NULL)
        ident_table = ident_table_new();
    ident_t *id = hash_table_get(ident_table, (void *)name, NULL);
    if (id == NULL) {
        id = ident_new(name);
        hash_table_set(ident_table, (void *)name, id);
    }
    return id;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8a09(%rip)      # 0xb310
jne 0x2923
leaq 0x357f(%rip), %rdi      # 0x5e8f
leaq 0x35a6(%rip), %rsi      # 0x5ebd
callq 0x5d50
movq %rax, 0x89ed(%rip)      # 0xb310
movq 0x89e6(%rip), %rdi      # 0xb310
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5e20
movq %rax, %r14
testq %rax, %rax
jne 0x296e
movl $0x18, %edi
callq 0x20e0
movq %rax, %r14
movq %rax, %rdi
callq 0x608c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6142
movq 0x89ad(%rip), %rdi      # 0xb310
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5db0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/vm.c
// Function: vm_new
vm_t *vm_new(void)
{
    vm_t *vm = malloc(sizeof(*vm));
    vm->depth = 0;
    vm->ip = 0;
    /* Environments */
    vm->denv = env_new(env_empty_new());
    vm->env = env_new(env_empty_new());
    vm->init_env = elo_extend_env(env_new(env_empty_new()));
    vm->global_env = vm->init_env;

    vm->traced_objs = hash_table_new(hash_ptr, comp_ptr);
    vm->stack = stack_new();
    vm->sys_stack = stack_new();
    return vm;
}

// Assembly:
pushq %rbx
movl $0x48, %edi
callq 0x20e0
movq %rax, %rbx
movq $0x0, (%rax)
callq 0x55f4
movq %rax, %rdi
callq 0x55f7
movq %rax, 0x8(%rbx)
callq 0x55f4
movq %rax, %rdi
callq 0x55f7
movq %rax, 0x10(%rbx)
callq 0x55f4
movq %rax, %rdi
callq 0x55f7
movq %rax, %rdi
callq 0x36fc
movq %rax, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x34b4(%rip), %rdi      # 0x5e8b
leaq 0x34d6(%rip), %rsi      # 0x5eb4
callq 0x5d50
movq %rax, 0x28(%rbx)
callq 0x6282
movq %rax, 0x30(%rbx)
callq 0x6282
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/vm.c
// Function: vm_free
void vm_free(vm_t *vm)
{
    env_free(vm->denv);
    env_free(vm->env);
    stack_free(vm->stack);
    stack_free(vm->sys_stack);
    free(vm);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x5622
movq 0x10(%rbx), %rdi
callq 0x5622
movq 0x30(%rbx), %rdi
callq 0x629d
movq 0x38(%rbx), %rdi
callq 0x629d
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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 0x6369
movq %rax, (%r14)
movq 0x38(%rbx), %rdi
callq 0x6369
movl %eax, 0x4(%rbx)
movq 0x38(%rbx), %rdi
callq 0x6369
movq %rax, (%r15)
movq 0x38(%rbx), %rdi
callq 0x6369
movq %rax, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x6369
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3130
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 0x5e20
testq %rax, %rax
je 0x3235
movq %rax, %r14
movq %rbx, %rdi
callq 0x32bb
movq 0x7e7a(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movl (%rbx), %edx
movq (%r14), %rcx
leaq 0x40fb(%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 0x31ae
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x31bc
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x321c
leaq 0x409e(%rip), %rbx      # 0x7269
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2755
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x31ef
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x31fd
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x321c
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2140
jmp 0x31cb
movq (%r15), %rcx
leaq 0x4046(%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_O1/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 0x5e20
testq %rax, %rax
je 0x32af
movq %rax, %r15
movq %r14, %rdi
callq 0x32bb
movq 0x7d5e(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movl (%r14), %edx
movq (%r15), %rcx
leaq 0x3fef(%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_O1/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 0x4655
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62ba
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4810
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62ba
callq 0x47e3
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62ba
callq 0x483c
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x62ba
// File: /workspace/github_c_makefile_star2_O1/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, 0x7bf1(%rip)      # 0xb300
je 0x3769
leaq 0x7a00(%rip), %r15      # 0xb118
xorl %r12d, %r12d
cmpl $0x0, -0x18(%r15)
je 0x373e
callq 0x6282
movq %rax, %r14
movq %rax, %rdi
callq *-0x8(%r15)
movl (%r15), %edi
movq %r14, %rsi
callq 0x26dd
jmp 0x374a
movq -0x8(%r15), %rdi
movl (%r15), %esi
callq 0x24f0
movq -0x10(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x567a
incq %r12
addq $0x20, %r15
cmpq %r12, 0x7b99(%rip)      # 0xb300
ja 0x371b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x55f4
movq %rax, %rdi
callq 0x55f7
movq %rax, %r15
movq %rax, 0x18(%rbx)
leaq 0x26de(%rip), %rdi      # 0x5e8f
leaq 0x2705(%rip), %rsi      # 0x5ebd
callq 0x5d50
movq %rax, %r14
movq %rax, 0x8(%rbx)
leaq 0x26c0(%rip), %rdi      # 0x5e8b
leaq 0x26e2(%rip), %rsi      # 0x5eb4
callq 0x5d50
movq %rax, 0x10(%rbx)
callq 0x55f4
movq %rax, %rdi
callq 0x55f7
movq %rbx, (%rsp)
movq %rax, 0x20(%rbx)
leaq 0x7b09(%rip), %r13      # 0xb300
cmpq $0x0, (%r13)
je 0x383c
leaq 0x78fb(%rip), %rbp      # 0xb100
addq $0x18, %rbp
xorl %ebx, %ebx
cmpl $0x0, -0x18(%rbp)
jne 0x382f
movq -0x10(%rbp), %r12
movq -0x8(%rbp), %rdi
movl (%rbp), %esi
callq 0x24f0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x567a
incq %rbx
addq $0x20, %rbp
cmpq %rbx, (%r13)
ja 0x380b
movl $0x8, %edi
callq 0x20e0
leaq 0x2f9(%rip), %rcx       # 0x3b46
movq %rcx, (%rax)
leaq 0x3b58(%rip), %rsi      # 0x73af
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x38e(%rip), %rcx       # 0x3c01
movq %rcx, (%rax)
leaq 0x3b21(%rip), %rsi      # 0x739e
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x3e6(%rip), %rcx       # 0x3c7f
movq %rcx, (%rax)
leaq 0x3afe(%rip), %rsi      # 0x73a1
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x447(%rip), %rcx       # 0x3d06
movq %rcx, (%rax)
leaq 0x3ade(%rip), %rsi      # 0x73a7
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x466(%rip), %rcx       # 0x3d4b
movq %rcx, (%rax)
leaq 0x3abf(%rip), %rsi      # 0x73ae
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x4a4(%rip), %rcx       # 0x3daf
movq %rcx, (%rax)
leaq 0x3a9e(%rip), %rsi      # 0x73b3
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x4e3(%rip), %rcx       # 0x3e14
movq %rcx, (%rax)
leaq 0x3a7d(%rip), %rsi      # 0x73b8
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x521(%rip), %rcx       # 0x3e78
movq %rcx, (%rax)
leaq 0x3a5e(%rip), %rsi      # 0x73bf
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x563(%rip), %rcx       # 0x3ee0
movq %rcx, (%rax)
leaq 0x3a3a(%rip), %rsi      # 0x73c1
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
movl $0x8, %edi
callq 0x20e0
leaq 0x5cb(%rip), %rcx       # 0x3f6e
movq %rcx, (%rax)
leaq 0x3a1a(%rip), %rsi      # 0x73c7
movq %r14, %rdi
movq %rax, %rdx
callq 0x5db0
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_O1/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 0x3b41
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x3977(%rip), %rcx      # 0x736c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %r12
cmpl $0x4, (%r12)
jne 0x3a87
movq 0x10(%r12), %rax
movq (%rax), %rsi
movq 0x8(%r15), %rdi
xorl %edx, %edx
callq 0x5e20
testq %rax, %rax
je 0x3ade
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 0x10(%r14), %rax
movq (%rax), %r12
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0x57f3
testq %rax, %rax
je 0x3aa9
testq %rbx, %rbx
je 0x3a60
movq %rax, (%rbx)
movl (%rax), %ebp
jmp 0x3acf
movl $0x5, %ebp
testq %rbx, %rbx
je 0x3acf
movl 0x10(%r14), %edi
jmp 0x3a80
movl $0x5, %ebp
testq %rbx, %rbx
je 0x3acf
xorl %edi, %edi
callq 0x267a
jmp 0x3acc
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3acf
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x39bf(%rip), %rdi      # 0x745f
xorl %eax, %eax
callq 0x2596
jmp 0x3acc
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3acf
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x390b(%rip), %rdi      # 0x73cd
movq %r12, %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 0x39cb
cmpl $0x4, %eax
je 0x3b10
movl $0x2, %ebp
cmpl $0x2, %eax
jne 0x3b28
testq %rbx, %rbx
je 0x3acf
movq 0x8(%rsp), %rax
jmp 0x3acc
movq 0x8(%rsp), %rsi
movq 0x18(%r14), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x4011
movl %eax, %ebp
jmp 0x3acf
testq %rbx, %rbx
je 0x3acf
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x395c(%rip), %rdi      # 0x7498
jmp 0x3aa0
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
movq $0x0, (%rdx)
callq 0x39cb
cmpl $0x2, %eax
je 0x3be3
movq %r15, %rdi
callq 0x5b4d
testl %eax, %eax
je 0x3bb8
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
movq 0x18(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x39cb
cmpl $0x2, %eax
jne 0x3bce
testq %rbx, %rbx
je 0x3baf
movq 0x8(%rsp), %rcx
movq %rcx, (%rbx)
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
jmp 0x3bde
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq (%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x567a
jmp 0x3be3
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
movq %rcx, (%rdx)
cmpl $0x2, %eax
je 0x3bf5
testq %rbx, %rbx
je 0x3bef
movq (%rsp), %rax
movq %rax, (%rbx)
movq (%rsp), %rax
movl (%rax), %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39cb
cmpl $0x2, %eax
jne 0x3c4e
testq %rbx, %rbx
je 0x3c46
movq (%rsp), %rax
movq %rax, (%rbx)
movq (%rsp), %rax
movl (%rax), %eax
jmp 0x3c6b
movq (%rsp), %rax
cmpl $0x5, (%rax)
jne 0x3c5d
cmpl $0x0, 0x8(%rax)
je 0x3c77
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x39cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r12, %rsi
jmp 0x3c63
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
cmpl $0x1, (%r15)
jne 0x3ce6
movq 0x18(%r15), %rax
cmpl $0x2, (%rax)
je 0x3ce6
movq 0x10(%r15), %rsi
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x39cb
cmpl $0x2, %eax
jne 0x3cdb
testq %rbx, %rbx
je 0x3cd2
movq 0x8(%rsp), %rcx
movq %rcx, (%rbx)
movq 0x8(%rsp), %rcx
movl (%rcx), %ebp
jmp 0x3cdf
movq 0x18(%r15), %r15
cmpl $0x2, %eax
jne 0x3c99
jmp 0x3cf7
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x39cb
movl %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b0e
movq 0x18(%r14), %rcx
movl %eax, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2711
testq %rbx, %rbx
je 0x3d3d
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39cb
cmpl $0x2, %eax
je 0x3d91
movq 0x20(%r14), %rdi
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x567a
testq %rbx, %rbx
je 0x3d9e
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x57f3
testq %rax, %rax
je 0x3de1
testq %rbx, %rbx
je 0x3ddd
movq %rax, (%rbx)
movl (%rax), %ebp
jmp 0x3e07
movl $0x2, %ebp
testq %rbx, %rbx
je 0x3e07
movl 0x4(%r15), %esi
movl 0x8(%r15), %edx
leaq 0x35d3(%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_O1/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 0x3576(%rip), %rdi      # 0x73a7
callq 0x59b3
movq %rax, %rdi
movq %r12, %rsi
callq 0x5963
movq %rax, %r12
callq 0x598d
movq %r12, %rdi
movq %rax, %rsi
callq 0x5963
movq %r15, %rdi
movq %rax, %rsi
callq 0x5963
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3b46
// File: /workspace/github_c_makefile_star2_O1/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 0x3eac
movq 0x18(%rdi), %rdi
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x58c6
testq %rbx, %rbx
je 0x3ed2
movq %rax, %rdi
callq 0x2692
movq %rax, %rcx
movl $0x6, %eax
jmp 0x3ecd
testq %rbx, %rbx
je 0x3ed9
movl 0x4(%rax), %esi
movl 0x8(%rax), %edx
leaq 0x353c(%rip), %rdi      # 0x73fa
xorl %eax, %eax
callq 0x2596
movq %rax, %rcx
movl $0x2, %eax
movq %rcx, (%rbx)
jmp 0x3ede
movl $0x6, %eax
jmp 0x3ede
movl $0x2, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x39cb
cmpl $0x2, %eax
jne 0x3f1c
testq %rbx, %rbx
je 0x3f15
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
jmp 0x3f3c
movq 0x8(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x3f49
testq %rbx, %rbx
je 0x3f35
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 0x3f3e
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x34cf(%rip), %rdi      # 0x7431
xorl %eax, %eax
callq 0x2596
movq %rax, (%rbx)
jmp 0x3f3e
// File: /workspace/github_c_makefile_star2_O1/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 0x39cb
cmpl $0x2, %eax
je 0x3ff3
movq 0x8(%rsp), %rcx
cmpl $0x4, (%rcx)
jne 0x3ff3
cmpl $0x4, (%r15)
jne 0x3fb3
movq 0x10(%r15), %rax
movq (%rax), %rdi
jmp 0x3fdd
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x3143(%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 0x5db0
testq %rbx, %rbx
je 0x4000
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movl (%rax), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4419
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 0x5e20
testq %rax, %rax
je 0x4533
movq %rax, %r14
movq %rbx, %rdi
callq 0x45dc
movq 0x6b91(%rip), %r15      # 0xafd0
movq (%r15), %rdi
movl (%rbx), %edx
leaq 0x3107(%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 0x44ac
movl $0x10, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x44ba
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x451a
leaq 0x2da0(%rip), %rbx      # 0x7269
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2755
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x44ed
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x44fb
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x451a
movq (%r15), %rcx
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2140
jmp 0x44c9
movq (%r15), %rcx
leaq 0x2d48(%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_O1/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 0x5e20
testq %rax, %rax
je 0x45d0
movq %rax, %r14
movq %r15, %rdi
callq 0x45dc
movq 0x6a60(%rip), %r12      # 0xafd0
movq (%r12), %rdi
movl (%r15), %edx
leaq 0x2fd4(%rip), %rsi      # 0x7552
xorl %eax, %eax
callq 0x20d0
movq (%r12), %rsi
movq (%r14), %rdi
callq 0x2070
movq (%r12), %rcx
leaq 0x2cdd(%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_O1/Liutos[P]Eloquent/bytecode.c
// Function: bc_fjump_new
bytecode_t *bc_fjump_new(bytecode_t *label)
{
    bytecode_t *bc = bc_new(BC_FJUMP);
    BC_FJUMP_INDEX(bc) = -1;
    bc->u.bc_fjump.label = label;
    return bc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x20e0
movl $0x7, (%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/bytecode.c
// Function: bc_gref_new
bytecode_t *bc_gref_new(int i, int j, char *name)
{
    bytecode_t *bc = bc_new(BC_GREF);
    BC_REF_I(bc) = i;
    BC_REF_J(bc) = j;
    BC_REF_NAME(bc) = name;
    return bc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0x20e0
movl $0x9, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/bytecode.c
// Function: bc_gset_new
bytecode_t *bc_gset_new(int i, int j, char *name)
{
    bytecode_t *bc = bc_new(BC_GSET);
    BC_SET_I(bc) = i;
    BC_SET_J(bc) = j;
    BC_SET_NAME(bc) = name;
    return bc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl $0x18, %edi
callq 0x20e0
movl $0xa, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Liutos[P]Eloquent/bytecode.c
// Function: bc_jump_new
bytecode_t *bc_jump_new(bytecode_t *label)
{
    bytecode_t *bc = bc_new(BC_JUMP);
    BC_JUMP_LABEL(bc) = label;
    BC_JUMP_INDEX(bc) = -1;
    return bc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x20e0
movl $0xb, (%rax)
movq %rbx, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6475(%rip), %rcx      # 0xad30
movq (%rcx,%rax,8), %rdi
callq 0x2070
movl (%r14), %eax
cmpq $0x14, %rax
ja 0x496c
leaq 0x2c80(%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 0x2cb8(%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 0x4918
movl 0x8(%r14), %edx
jmp 0x4934
movq 0x8(%r14), %rdx
leaq 0x27ad(%rip), %rsi      # 0x70cc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl 0x10(%r14), %edx
leaq 0x2e0b(%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_O1/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 0x4a6b
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 0x637e
movq %rax, %r13
movl (%rax), %eax
cmpl $0x10, %eax
je 0x49c9
cmpl $0xc, %eax
jne 0x4a39
jmp 0x4a7a
movq 0x8(%r13), %rbp
cmpl $0x4, (%rbp)
jne 0x4a39
cmpl $0x0, 0xc(%rbp)
je 0x4a39
movl %ebx, %edi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4a99
movl $0x20, %esi
movl $0x1, %edx
leaq 0x2c17(%rip), %rdi      # 0x760e
movq %r14, %rcx
callq 0x2140
movq 0x20(%rbp), %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x4982
movl %ebx, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r14, %rdx
callq 0x4a99
movl $0x9, %esi
movl $0x1, %edx
leaq 0x2c00(%rip), %rdi      # 0x762f
movq %r14, %rcx
callq 0x2140
jmp 0x4a51
movl %ebx, %edi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4a99
movq %r13, %rdi
movq %r14, %rsi
callq 0x48a8
movl $0xa, %edi
movq %r14, %rsi
callq 0x20a0
incq %r12
cmpq %r12, 0x10(%r15)
ja 0x49aa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b37(%rip), %rdi      # 0x75b8
leaq 0x2b4a(%rip), %rsi      # 0x75d2
leaq 0x2b4e(%rip), %rcx      # 0x75dd
movl $0x106, %edx            # imm = 0x106
callq 0x2060
// File: /workspace/github_c_makefile_star2_O1/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 0x4ac2
movl %edi, %r14d
incl %r14d
movl $0x9, %edi
movq %rbx, %rsi
callq 0x20a0
decl %r14d
cmpl $0x1, %r14d
jg 0x4aac
cmpl $-0x1, %ebp
je 0x4ada
leaq 0x2b3b(%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