LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/key.c
// Function: SH_Key__hash
uint8_t
SH_Key__hash(SH_Key* obj, int* err) {
	size_t buflen;
	uint8_t* ptr;
	uint8_t hsh = UINT8_C(1);

	__cascade(err, UINT8_C(0));

	buflen = obj->length; /* assumes sizeof(uint8_t) and sizeof(sh_char_t) are both 1 */
	ptr = (uint8_t*)(obj->value);

	for (; buflen > 0; buflen--) {
		hsh = (hsh << 3) | (hsh >> 5);
		hsh ^= (uint8_t)*ptr;
		ptr++;
	}

	__clear(err);
	return hsh;
}

// Assembly:
testq %rsi, %rsi
je 0x12a6
cmpl $0x0, (%rsi)
je 0x12a6
xorl %eax, %eax
retq
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movb $0x1, %al
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x12c1
rolb $0x3, %al
xorb (%rcx,%rdi), %al
incq %rdi
jmp 0x12b1
testq %rsi, %rsi
je 0x12a5
andl $0x0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/key.c
// Function: SH_Key__equal
sh_bool_t
SH_Key__equal(SH_Key* obj, SH_Key* other, int* err) {
	size_t i;

	__cascade(err, SH_FALSE);

	if (obj->length != other->length) {
		__clear(err);
		return SH_FALSE;
	}

	for (i = 0; i < obj->length; i++) {
		if (obj->value[i] != other->value[i]) {
			__clear(err);
			return SH_FALSE;
		}
	}

	__clear(err);
	return SH_TRUE;
}

// Assembly:
testq %rdx, %rdx
je 0x12e2
cmpl $0x0, (%rdx)
jne 0x130e
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
je 0x12ec
xorl %eax, %eax
jmp 0x1318
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x130e
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x1311
movq (%rdi), %r8
movb (%r8,%rcx), %r8b
movq (%rsi), %r9
leaq 0x1(%rcx), %r10
cmpb (%r9,%rcx), %r8b
movq %r10, %rcx
je 0x12ee
xorl %eax, %eax
jmp 0x1313
xorl %eax, %eax
retq
movb $-0x1, %al
testq %rdx, %rdx
je 0x1310
andl $0x0, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/phluid61[P]hsf/src/key.c
// Function: SH_Key__to_s
sh_char_t*
SH_Key__to_s(SH_Key* obj, int* err) {
	sh_char_t* str;

	__cascade(err, (sh_char_t*)0);

	str = (sh_char_t*)malloc(sizeof(sh_char_t) * (obj->length + 1)); /*FIXME*/
	if ((sh_char_t*)0 == str) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	memcpy((void*)str, (const void*)(obj->value), obj->length + 1);

	__clear(err);
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x1339
cmpl $0x0, (%rbx)
je 0x1339
xorl %r14d, %r14d
jmp 0x1371
movq 0x8(%r15), %r12
incq %r12
movq %r12, %rdi
callq 0x1060
testq %rax, %rax
je 0x1362
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x1050
xorl %eax, %eax
jmp 0x136a
movl $0x80000001, %eax       # imm = 0x80000001
xorl %r14d, %r14d
testq %rbx, %rbx
je 0x1371
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7d6a(%rip), %rax      # 0x9fd8
movq (%rax), %rdi
callq 0x575c
movq %rax, %rdi
callq 0x5118
movq %rax, %rbx
callq 0x47cc
movq %rax, %r14
callq 0x283c
movq %rax, %r15
movq %rsp, %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x23b7
movq 0x7d29(%rip), %r12      # 0x9fd0
pushq $0x1
popq %r13
testl %eax, %eax
je 0x239a
cmpl $0x3, %eax
je 0x239a
movq (%r12), %rcx
leaq 0x3d3d(%rip), %rdi      # 0x6004
pushq $0x6
popq %rsi
movq %r13, %rdx
callq 0x2140
movq (%r12), %rdi
callq 0x20f0
movq (%rsp), %rdi
movq (%r12), %rsi
callq 0x55fe
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x20a0
callq 0x5dbb
movq %rax, %rbp
movq (%rsp), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x4e26
movq (%r12), %rcx
cmpl $0x1, %eax
jne 0x2372
leaq 0x3cf0(%rip), %rdi      # 0x600b
pushq $0xb
popq %rsi
movq %r13, %rdx
callq 0x2140
movq (%r12), %rsi
movq %rbp, %rdi
xorl %edx, %edx
callq 0x465b
movq (%r12), %rcx
leaq 0x3cd8(%rip), %rdi      # 0x6017
pushq $0x5
popq %rsi
movq %r13, %rdx
callq 0x2140
movq %r15, %rdi
movq %rbp, %rsi
callq 0x28ea
callq 0x5dbb
movq %rax, %rbp
movq %rax, %rdi
callq 0x2f86
movq %r15, %rdi
movq %rbp, %rsi
callq 0x28ea
jmp 0x238a
movq 0x30(%r14), %rax
movq (%rax), %rdx
movq %rcx, %rdi
leaq 0x3c9a(%rip), %rsi      # 0x601d
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x23b7
jmp 0x22ab
movq (%r12), %rsi
pushq $0xa
popq %rdi
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_O2/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
pushq $0x4
popq %rdi
callq 0x2420
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_O2/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
xorl %edi, %edi
callq 0x2420
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rdi
callq 0x2420
movq %rax, %r14
callq 0x5c20
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5c89
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4
popq %rdi
callq 0x2420
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_O2/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
pushq $0x4
popq %rdi
callq 0x2420
movl %ebp, 0x10(%rax)
andq $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_O2/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
movl (%rdi), %edx
cmpq $0x7, %rdx
ja 0x2784
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3a10(%rip), %rax      # 0x6040
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%r14), %r15
movq 0x10(%r14), %r14
pushq $0x28
popq %rdi
movq %rbx, %rsi
callq 0x20a0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2612
cmpl $0x1, (%r14)
je 0x267d
leaq 0x3aa6(%rip), %rdi      # 0x610a
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2612
pushq $0x29
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20a0
cmpl $0x0, 0x8(%r14)
je 0x272f
movq 0x20(%r14), %rdx
leaq 0x3a6b(%rip), %rsi      # 0x610e
jmp 0x2720
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x3a13(%rip), %rsi      # 0x60c6
jmp 0x2720
movsd 0x8(%r14), %xmm0
leaq 0x3a0e(%rip), %rsi      # 0x60d0
movq %rbx, %rdi
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
movq 0x8(%r14), %rax
movq (%rax), %rdx
leaq 0x39fe(%rip), %rsi      # 0x60dd
jmp 0x2720
leaq 0x39db(%rip), %rdi      # 0x60c3
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x2140
movl 0x8(%r14), %edx
leaq 0x40b9(%rip), %rsi      # 0x67bf
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
movq 0x8(%r14), %rdx
leaq 0x39b3(%rip), %rsi      # 0x60d3
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x20d0
cmpl $0x0, 0xc(%r14)
je 0x2745
leaq 0x39d1(%rip), %rsi      # 0x610e
movq %rbx, %rdi
movq %r14, %rdx
jmp 0x2723
leaq 0x39c8(%rip), %rdi      # 0x6114
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2140
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x55fe
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x20a0
movq 0x28(%r14), %rdi
movq %rbx, %rsi
callq 0x55fe
pushq $0x3e
jmp 0x267f
movq 0x786d(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x3953(%rip), %rsi      # 0x60e8
xorl %eax, %eax
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x7b46(%rip), %rdi      # 0xa310
testq %rdi, %rdi
jne 0x27ec
leaq 0x3264(%rip), %rdi      # 0x5a3a
leaq 0x3282(%rip), %rsi      # 0x5a5f
callq 0x58fc
movq %rax, %rdi
movq %rax, 0x7b24(%rip)      # 0xa310
movq %rbx, %rsi
xorl %edx, %edx
callq 0x59c8
movq %rax, %r14
testq %rax, %rax
jne 0x282e
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %r14
movq %rax, %rdi
callq 0x5bfc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c89
movq 0x7aed(%rip), %rdi      # 0xa310
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5953
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x20e0
movq %rax, %rbx
andq $0x0, (%rax)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, 0x8(%rbx)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, 0x10(%rbx)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, %rdi
callq 0x35d8
movq %rax, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x31a4(%rip), %rdi      # 0x5a36
leaq 0x31bd(%rip), %rsi      # 0x5a56
callq 0x58fc
movq %rax, 0x28(%rbx)
callq 0x5dbb
movq %rax, 0x30(%rbx)
callq 0x5dbb
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52c0
movq 0x10(%rbx), %rdi
callq 0x52c0
movq 0x30(%rbx), %rdi
callq 0x5dc6
movq 0x38(%rbx), %rdi
callq 0x5dc6
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 0x5e8a
movq %rax, (%r14)
movq 0x38(%rbx), %rdi
callq 0x5e8a
movl %eax, 0x4(%rbx)
movq 0x38(%rbx), %rdi
callq 0x5e8a
movq %rax, (%r15)
movq 0x38(%rbx), %rdi
callq 0x5e8a
movq %rax, 0x10(%rbx)
movq 0x38(%rbx), %rdi
callq 0x5e8a
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
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 0x2ffd
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)
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x3182
testl %eax, %eax
je 0x3105
movq %rbx, %rdi
callq 0x31c2
movq 0x6fae(%rip), %r13      # 0x9fd0
movq (%r13), %rdi
movl (%rbx), %edx
movq 0x18(%rsp), %rax
movq (%rax), %rcx
leaq 0x3229(%rip), %rsi      # 0x6260
xorl %eax, %eax
callq 0x20d0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
pushq $0x10
popq %rcx
cmpq $0x28, %rcx
ja 0x307c
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x308a
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r12
leaq 0x31d5(%rip), %rbx      # 0x6269
pushq $0x2
popq %r14
pushq $0x1
popq %r15
movq (%r13), %rcx
testq %r12, %r12
je 0x30f3
movq %r12, %rdi
movq %rcx, %rsi
callq 0x2612
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x30c9
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x30d7
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r12
testq %r12, %r12
je 0x309c
movq (%r13), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
jmp 0x309c
leaq 0x3172(%rip), %rdi      # 0x626c
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2140
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x3182
testl %eax, %eax
je 0x3178
movq %r14, %rdi
callq 0x31c2
movq 0x6e8a(%rip), %r15      # 0x9fd0
movq (%r15), %rdi
movl (%r14), %edx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
leaq 0x3154(%rip), %rsi      # 0x62af
xorl %eax, %eax
callq 0x20d0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2612
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x20a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x43ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5de3
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4519
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5de3
callq 0x44ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5de3
callq 0x453d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x5de3
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x6b2e(%rip), %r15      # 0xa118
xorl %r12d, %r12d
cmpq %r12, 0x6d0c(%rip)      # 0xa300
jbe 0x363d
cmpl $0x0, -0x18(%r15)
je 0x3619
callq 0x5dbb
movq %rax, %r14
movq %rax, %rdi
callq *-0x8(%r15)
movl (%r15), %edi
movq %r14, %rsi
callq 0x25ad
jmp 0x3625
movq -0x8(%r15), %rdi
movl (%r15), %esi
callq 0x23f8
movq -0x10(%r15), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x5321
incq %r12
addq $0x20, %r15
jmp 0x35ed
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq $0x28
popq %rdi
callq 0x20e0
movq %rax, %rbx
andl $0x0, (%rax)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, 0x18(%rbx)
leaq 0x23bf(%rip), %rdi      # 0x5a3a
leaq 0x23dd(%rip), %rsi      # 0x5a5f
callq 0x58fc
movq %rax, 0x8(%rbx)
leaq 0x23a4(%rip), %rdi      # 0x5a36
leaq 0x23bd(%rip), %rsi      # 0x5a56
callq 0x58fc
movq %rax, 0x10(%rbx)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, 0x20(%rbx)
leaq 0x6a46(%rip), %r15      # 0xa100
addq $0x18, %r15
leaq 0x6c3b(%rip), %r12      # 0xa300
movq (%r12), %rax
xorl %r13d, %r13d
cmpq %r13, %rax
jbe 0x3703
cmpl $0x0, -0x18(%r15)
jne 0x36fa
movq -0x10(%r15), %r14
movq -0x8(%r15), %rdi
movl (%r15), %esi
callq 0x23f8
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4115
movq (%r12), %rax
incq %r13
addq $0x20, %r15
jmp 0x36cc
leaq 0x2ce1(%rip), %rsi      # 0x63eb
leaq 0x592(%rip), %rdx       # 0x3ca3
movq %rbx, %rdi
callq 0x3c76
leaq 0x2cba(%rip), %rsi      # 0x63da
leaq 0x627(%rip), %rdx       # 0x3d4e
movq %rbx, %rdi
callq 0x3c76
leaq 0x2ca7(%rip), %rsi      # 0x63dd
leaq 0x688(%rip), %rdx       # 0x3dc5
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c97(%rip), %rsi      # 0x63e3
leaq 0x6df(%rip), %rdx       # 0x3e32
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c88(%rip), %rsi      # 0x63ea
leaq 0x70e(%rip), %rdx       # 0x3e77
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c77(%rip), %rsi      # 0x63ef
leaq 0x754(%rip), %rdx       # 0x3ed3
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c66(%rip), %rsi      # 0x63f4
leaq 0x7a1(%rip), %rdx       # 0x3f36
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c57(%rip), %rsi      # 0x63fb
leaq 0x7ef(%rip), %rdx       # 0x3f9a
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c43(%rip), %rsi      # 0x63fd
leaq 0x837(%rip), %rdx       # 0x3ff8
movq %rbx, %rdi
callq 0x3c76
leaq 0x2c33(%rip), %rsi      # 0x6403
leaq 0x8a5(%rip), %rdx       # 0x407c
movq %rbx, %rdi
callq 0x3c76
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
callq 0x37ec
cmpl $0x2, %eax
je 0x3d25
movq %r15, %rdi
callq 0x571a
testl %eax, %eax
je 0x3d11
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq 0x18(%r15), %rax
movq 0x10(%rax), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x37ec
movq (%r12), %rcx
cmpl $0x2, %eax
jne 0x3d40
testq %rbx, %rbx
je 0x3d0d
movq %rcx, (%rbx)
movl (%rcx), %eax
jmp 0x3d34
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x4115
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x3d32
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 0x3d2a
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
movq %rax, %rsi
callq 0x37ec
cmpl $0x2, %eax
jne 0x3d94
movq (%rsp), %rax
testq %rbx, %rbx
je 0x3d90
movq %rax, (%rbx)
movl (%rax), %eax
jmp 0x3db1
movq (%rsp), %rax
cmpl $0x5, (%rax)
jne 0x3da3
cmpl $0x0, 0x8(%rax)
je 0x3dbd
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x37ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r12, %rsi
jmp 0x3da9
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsp, %r12
cmpl $0x1, (%r15)
jne 0x3e07
movq 0x18(%r15), %rax
cmpl $0x2, (%rax)
je 0x3e07
movq 0x10(%r15), %rsi
andq $0x0, (%rsp)
movq %r14, %rdi
movq %r12, %rdx
callq 0x37ec
cmpl $0x2, %eax
je 0x3e18
movq 0x18(%r15), %r15
jmp 0x3dd9
movq 0x10(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37ec
jmp 0x3e26
movq (%rsp), %rax
testq %rbx, %rbx
je 0x3e24
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x56df
movq 0x18(%r14), %rcx
movl %eax, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x25d9
testq %rbx, %rbx
je 0x3e69
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
callq 0x37ec
cmpl $0x2, %eax
je 0x3eba
movq 0x20(%r14), %rdi
movq 0x10(%r15), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x5321
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x3ec7
movq %rax, (%rbx)
movl (%rax), %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5453
testq %rax, %rax
je 0x3f05
testq %rbx, %rbx
je 0x3f01
movq %rax, (%rbx)
movl (%rax), %ebp
jmp 0x3f29
pushq $0x2
popq %rbp
testq %rbx, %rbx
je 0x3f29
movl 0x4(%r15), %esi
movl 0x8(%r15), %edx
leaq 0x24ed(%rip), %rdi      # 0x6409
movq %r14, %rcx
xorl %eax, %eax
callq 0x2486
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2490(%rip), %rdi      # 0x63e3
callq 0x5587
movq %rax, %rdi
movq %r12, %rsi
callq 0x555b
movq %rax, %r12
callq 0x557d
movq %r12, %rdi
movq %rax, %rsi
callq 0x555b
movq %r15, %rdi
movq %rax, %rsi
callq 0x555b
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ca3
// File: /workspace/github_c_makefile_star2_O2/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 0x3fcb
movq 0x18(%rdi), %rdi
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x54e7
testq %rbx, %rbx
je 0x3fef
movq %rax, %rdi
callq 0x2572
movq %rax, %rcx
pushq $0x6
jmp 0x3fe9
testq %rbx, %rbx
je 0x3ff3
movl 0x4(%rax), %esi
movl 0x8(%rax), %edx
leaq 0x2459(%rip), %rdi      # 0x6436
xorl %eax, %eax
callq 0x2486
movq %rax, %rcx
pushq $0x2
popq %rax
movq %rcx, (%rbx)
jmp 0x3ff6
pushq $0x6
jmp 0x3ff5
pushq $0x2
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
movq %r14, %rsi
callq 0x37ec
cmpl $0x2, %eax
jne 0x402c
movq 0x8(%rsp), %rax
testq %rbx, %rbx
je 0x404c
movq %rax, (%rbx)
jmp 0x404c
movq 0x8(%rsp), %rax
cmpl $0x6, (%rax)
jne 0x4059
testq %rbx, %rbx
je 0x4045
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
pushq $0x2
popq %rbp
testq %rbx, %rbx
je 0x404e
movl 0x4(%r14), %esi
movl 0x8(%r14), %edx
leaq 0x23fd(%rip), %rdi      # 0x646d
xorl %eax, %eax
callq 0x2486
movq %rax, (%rbx)
jmp 0x404e
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdx)
movq %r15, %rsi
callq 0x37ec
cmpl $0x2, %eax
je 0x40fc
movq 0x8(%rsp), %rcx
cmpl $0x4, (%rcx)
jne 0x4101
cmpl $0x4, (%r15)
jne 0x40be
movq 0x10(%r15), %rax
movq (%rax), %rdi
jmp 0x40e6
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x2038(%rip), %rdx      # 0x610e
pushq $0x20
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x27bc
movq 0x10(%r14), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x5953
movq 0x8(%rsp), %rcx
testq %rbx, %rbx
je 0x4109
movq %rcx, (%rbx)
movl (%rcx), %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
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 0x4180
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)
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x4337
testl %eax, %eax
je 0x429d
movq %rbx, %rdi
callq 0x4377
movq 0x5e2b(%rip), %r13      # 0x9fd0
movq (%r13), %rdi
movl (%rbx), %edx
leaq 0x23e5(%rip), %rsi      # 0x6597
xorl %eax, %eax
callq 0x20d0
movq (%r13), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq (%r13), %rsi
pushq $0x28
popq %rdi
callq 0x20a0
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
pushq $0x10
popq %rcx
cmpq $0x28, %rcx
ja 0x4214
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x4222
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r12
leaq 0x203d(%rip), %rbx      # 0x6269
pushq $0x2
popq %r14
pushq $0x1
popq %r15
movq (%r13), %rcx
testq %r12, %r12
je 0x428b
movq %r12, %rdi
movq %rcx, %rsi
callq 0x2612
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x4261
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x426f
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r12
testq %r12, %r12
je 0x4234
movq (%r13), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2140
jmp 0x4234
leaq 0x1fda(%rip), %rdi      # 0x626c
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2140
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x4337
testl %eax, %eax
je 0x432d
movq %r14, %rdi
callq 0x4377
movq 0x5cf2(%rip), %r15      # 0x9fd0
movq (%r15), %rdi
movl (%r14), %edx
leaq 0x22ac(%rip), %rsi      # 0x6597
xorl %eax, %eax
callq 0x20d0
movq (%r15), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x2070
movq (%r15), %rcx
leaq 0x1faa(%rip), %rdi      # 0x62b6
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x2140
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x2612
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x20a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x7
popq %rdi
callq 0x43f0
orl $-0x1, 0x10(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x9
popq %rdi
callq 0x43f0
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_O2/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
pushq $0xa
popq %rdi
callq 0x43f0
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_O2/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
pushq $0xb
popq %rdi
callq 0x43f0
movq %rbx, 0x8(%rax)
orl $-0x1, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Liutos[P]Eloquent/bytecode.c
// Function: bc_ref_new
bytecode_t *bc_ref_new(int i, int j, char *name)
{
    bytecode_t *bc = bc_new(BC_REF);
    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
pushq $0x11
popq %rdi
callq 0x43f0
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_O2/Liutos[P]Eloquent/bytecode.c
// Function: bc_set_new
bytecode_t *bc_set_new(int i, int j, char *name)
{
    bytecode_t *bc = bc_new(BC_SET);
    bc->u.bc_set.i = i;
    bc->u.bc_set.j = j;
    bc->u.bc_set.name = name;
    return bc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x13
popq %rdi
callq 0x43f0
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_O2/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 0x579a(%rip), %rcx      # 0x9d30
movq (%rcx,%rax,8), %rdi
callq 0x2070
movl (%r14), %eax
cmpq $0x14, %rax
ja 0x4645
leaq 0x201d(%rip), %rcx      # 0x65d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %edx
movl 0xc(%r14), %ecx
movq 0x10(%r14), %r8
leaq 0x2055(%rip), %rsi      # 0x6624
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movq 0x8(%r14), %rax
movq (%rax), %rdx
jmp 0x45f3
movl 0x8(%r14), %edx
jmp 0x460f
movq 0x8(%r14), %rdx
leaq 0x1ad2(%rip), %rsi      # 0x60cc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
movl 0x10(%r14), %edx
leaq 0x21a8(%rip), %rsi      # 0x67be
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x20a0
movq 0x8(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2612
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0x14(%rsp)
xorl %r12d, %r12d
pushq $0xa
popq %rbx
cmpq %r12, 0x10(%r15)
jbe 0x4748
movq %r15, %rdi
movq %r12, %rsi
callq 0x5e9f
movq %rax, %rbp
movl (%rax), %eax
cmpl $0x10, %eax
je 0x46aa
cmpl $0xc, %eax
jne 0x471b
jmp 0x4757
movq 0x8(%rbp), %r13
cmpl $0x4, (%r13)
jne 0x471b
cmpl $0x0, 0xc(%r13)
je 0x471b
movq 0x8(%rsp), %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4776
leaq 0x1fb3(%rip), %rdi      # 0x6686
pushq $0x20
popq %rsi
pushq $0x1
popq %rbp
movq %rbp, %rdx
movq %r14, %rcx
callq 0x2140
movq 0x20(%r13), %rdi
movq %r14, %rsi
movl 0x14(%rsp), %edx
callq 0x465b
movq 0x8(%rsp), %rdi
pushq $-0x1
popq %rsi
movq %r14, %rdx
callq 0x4776
leaq 0x1f9c(%rip), %rdi      # 0x66a7
pushq $0x9
popq %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x2140
jmp 0x4736
movq 0x8(%rsp), %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x4776
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4583
movl %ebx, %edi
movq %r14, %rsi
callq 0x20a0
incq %r12
jmp 0x4681
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ed2(%rip), %rdi      # 0x6630
leaq 0x1ee5(%rip), %rsi      # 0x664a
leaq 0x1ee9(%rip), %rcx      # 0x6655
movl $0x106, %edx            # imm = 0x106
callq 0x2060
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
pushq $0x9
popq %r15
testl %r14d, %r14d
jle 0x479e
decl %r14d
movl %r15d, %edi
movq %rbx, %rsi
callq 0x20a0
jmp 0x4789
cmpl $-0x1, %ebp
je 0x47b6
leaq 0x1ed7(%rip), %rsi      # 0x6681
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x20d0
pushq $0x9
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x20e0
movq %rax, %rbx
callq 0x5c20
movq %rax, 0x30(%rbx)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, 0x8(%rbx)
callq 0x5294
movq %rax, %rdi
callq 0x5297
movq %rax, %rdi
callq 0x35d8
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
leaq 0x1220(%rip), %r14      # 0x5a3a
leaq 0x123e(%rip), %r15      # 0x5a5f
movq %r14, %rdi
movq %r15, %rsi
callq 0x58fc
movq %rax, 0x20(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x58fc
movq %rax, 0x28(%rbx)
leaq 0x1b97(%rip), %rsi      # 0x63dd
leaq 0xe3(%rip), %rdx        # 0x4930
movq %rbx, %rdi
callq 0x4927
leaq 0x1b8f(%rip), %rsi      # 0x63eb
leaq 0x12f(%rip), %rdx       # 0x4992
movq %rbx, %rdi
callq 0x4927
leaq 0x1b68(%rip), %rsi      # 0x63da
leaq 0x23d(%rip), %rdx       # 0x4ab6
movq %rbx, %rdi
callq 0x4927
leaq 0x1b5b(%rip), %rsi      # 0x63e3
leaq 0x2fd(%rip), %rdx       # 0x4b8c
movq %rbx, %rdi
callq 0x4927
leaq 0x1b51(%rip), %rsi      # 0x63ef
leaq 0x3d8(%rip), %rdx       # 0x4c7d
movq %rbx, %rdi
callq 0x4927
leaq 0x1b36(%rip), %rsi      # 0x63ea
leaq 0x3e6(%rip), %rdx       # 0x4ca1
movq %rbx, %rdi
callq 0x4927
leaq 0x1b2a(%rip), %rsi      # 0x63f4
leaq 0x412(%rip), %rdx       # 0x4ce3
movq %rbx, %rdi
callq 0x4927
leaq 0x1b1b(%rip), %rsi      # 0x63fb
leaq 0x460(%rip), %rdx       # 0x4d47
movq %rbx, %rdi
callq 0x4927
leaq 0x1b07(%rip), %rsi      # 0x63fd
leaq 0x491(%rip), %rdx       # 0x4d8e
movq %rbx, %rdi
callq 0x4927
leaq 0x1af7(%rip), %rsi      # 0x6403
leaq 0x4a5(%rip), %rdx       # 0x4db8
movq %rbx, %rdi
callq 0x4927
andl $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq