LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x146b
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x146b
movb $0x0, -0x1(%rbp)
jmp 0x150b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x1495
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x148f
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x150b
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x14f5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x14e5
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x14df
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x150b
jmp 0x14e7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x149d
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1507
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x153c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x153c
movq $0x0, -0x8(%rbp)
jmp 0x15af
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1579
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x156f
movq -0x18(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x15af
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x1, %rdx
callq 0x1050
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x15a7
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xcd7b(%rip), %rax      # 0xefd8
movq (%rax), %rdi
callq 0x86b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7a30
movq %rax, -0x20(%rbp)
callq 0x6920
movq %rax, -0x28(%rbp)
callq 0x2c00
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x23f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x23cd
cmpl $0x3, -0x3c(%rbp)
jne 0x22b5
jmp 0x23cd
movq 0xcd14(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x7d3e(%rip), %rsi      # 0xa004
movb $0x0, %al
callq 0x20c0
movq 0xccfc(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
movq 0xcce9(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x8480
movq 0xccda(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
callq 0x94a0
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x7310
cmpl $0x1, %eax
jne 0x2395
movq 0xcca7(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x7cd8(%rip), %rsi      # 0xa00b
movb $0x0, %al
callq 0x20c0
movq -0x48(%rbp), %rdi
movq 0xcc8b(%rip), %rax      # 0xefd0
movq (%rax), %rsi
xorl %edx, %edx
callq 0x66f0
movq 0xcc7a(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x7cb7(%rip), %rsi      # 0xa017
movb $0x0, %al
callq 0x20c0
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2d30
callq 0x94a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x39b0
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2d30
jmp 0x23b8
movq 0xcc34(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdx
leaq 0x7c6c(%rip), %rsi      # 0xa01d
movb $0x0, %al
callq 0x20c0
movq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x23f0
movl %eax, -0x3c(%rbp)
jmp 0x22a0
movq 0xcbfc(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x4, %edi
callq 0x24a0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x24a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
callq 0x24a0
movq %rax, -0x10(%rbp)
callq 0x9170
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x92b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
testb %al, %al
je 0x25b7
movaps %xmm0, -0x1a0(%rbp)
movaps %xmm1, -0x190(%rbp)
movaps %xmm2, -0x180(%rbp)
movaps %xmm3, -0x170(%rbp)
movaps %xmm4, -0x160(%rbp)
movaps %xmm5, -0x150(%rbp)
movaps %xmm6, -0x140(%rbp)
movaps %xmm7, -0x130(%rbp)
movq %r9, -0x1a8(%rbp)
movq %r8, -0x1b0(%rbp)
movq %rcx, -0x1b8(%rbp)
movq %rdx, -0x1c0(%rbp)
movq %rsi, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1d0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0xb0(%rbp)
movaps %xmm0, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
movaps %xmm0, -0xe0(%rbp)
movaps %xmm0, -0xf0(%rbp)
movaps %xmm0, -0x100(%rbp)
movaps %xmm0, -0x110(%rbp)
movaps %xmm0, -0x120(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x120(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
movl $0x100, %esi            # imm = 0x100
leaq -0x20(%rbp), %rcx
callq 0x2040
movq -0x1d8(%rbp), %rdi
callq 0x2520
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, %edi
callq 0x24a0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x4, %edi
callq 0x24a0
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x2968
movq -0x18(%rbp), %rax
leaq 0x77b1(%rip), %rcx      # 0xa040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29a0
jmp 0x2990
movq -0x10(%rbp), %rdi
leaq 0x780e(%rip), %rsi      # 0xa0c3
movb $0x0, %al
callq 0x20c0
jmp 0x2990
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
leaq 0x77ef(%rip), %rsi      # 0xa0c6
movb $0x0, %al
callq 0x20c0
jmp 0x2990
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x77d9(%rip), %rsi      # 0xa0d0
movb $0x1, %al
callq 0x20c0
jmp 0x2990
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a20
jmp 0x2990
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x7f43(%rip), %rsi      # 0xa867
movb $0x0, %al
callq 0x20c0
jmp 0x2990
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x7793(%rip), %rsi      # 0xa0d3
movb $0x0, %al
callq 0x20c0
jmp 0x2990
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
leaq 0x777e(%rip), %rsi      # 0xa0dd
movb $0x0, %al
callq 0x20c0
jmp 0x2990
movq 0xc689(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x7769(%rip), %rsi      # 0xa0e8
movb $0x0, %al
callq 0x20c0
movl $0x1, %edi
callq 0x2120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/value.c
// Function: value_print_cons
static void value_print_cons(value_t *cons, FILE *output)
{
    value_t *car = VALUE_CONS_CAR(cons);
    value_t *cdr = VALUE_CONS_CDR(cons);
    fputc('(', output);
    value_print(car, output);
    if (elo_type(cdr) != VALUE_END_OF_CONS) {
        fprintf(output, " . ");
        value_print(cdr, output);
    }
    fputc(')', output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movl $0x28, %edi
callq 0x2090
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2860
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x2a0b
movq -0x10(%rbp), %rdi
leaq 0x7713(%rip), %rsi      # 0xa10a
movb $0x0, %al
callq 0x20c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2860
movq -0x10(%rbp), %rsi
movl $0x29, %edi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/value.c
// Function: value_function_print
static void value_function_print(value_t *v, FILE *output)
{
    if (VALUE_FUNC_ISBIF(v)) {
        fprintf(output, "#<%p>", VALUE_BIF_PTR(v));
    } else if (!VALUE_FUNC_ISCMP(v)) {
        fprintf(output, "#<");
        ast_print(VALUE_UDF_PARS(v), output);
        fputc(' ', output);
        ast_print(VALUE_UDF_BODY(v), output);
        fprintf(output, ">");
    } else {
        fprintf(output, "#<%p>", v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x2a56
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0x76c1(%rip), %rsi      # 0xa10e
movb $0x0, %al
callq 0x20c0
jmp 0x2ace
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x2ab6
movq -0x10(%rbp), %rdi
leaq 0x76a9(%rip), %rsi      # 0xa114
movb $0x0, %al
callq 0x20c0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8480
movq -0x10(%rbp), %rsi
movl $0x20, %edi
callq 0x2090
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8480
movq -0x10(%rbp), %rdi
leaq 0x7caa(%rip), %rsi      # 0xa757
movb $0x0, %al
callq 0x20c0
jmp 0x2acc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x7649(%rip), %rsi      # 0xa10e
movb $0x0, %al
callq 0x20c0
jmp 0x2ace
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0xc874(%rip)      # 0xf3b8
jne 0x2b52
callq 0x2ba0
movq %rax, 0xc866(%rip)      # 0xf3b8
movq 0xc85f(%rip), %rdi      # 0xf3b8
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x8c70
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b92
movq -0x8(%rbp), %rdi
callq 0x2bc0
movq %rax, -0x10(%rbp)
movq 0xc833(%rip), %rdi      # 0xf3b8
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x8b30
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/ident.c
// Function: ident_new
static ident_t *ident_new(const char *name)
{
    ident_t *id = malloc(sizeof(ident_t));
    string_init(&id->name);
    string_assign(&id->name, name);
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9120
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x92b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x48, %edi
callq 0x20d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
callq 0x7d70
movq %rax, %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x7d70
movq %rax, %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x7d70
movq %rax, %rdi
callq 0x7d80
movq %rax, %rdi
callq 0x4790
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x608e(%rip), %rdi      # 0x8d20
leaq 0x60f7(%rip), %rsi      # 0x8d90
callq 0x8a80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
callq 0x94a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
callq 0x94a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7dc0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7dc0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x94d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x94d0
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/vm.c
// Function: vm_execute_bif
static void vm_execute_bif(vm_t *vm, value_t *f)
{
    value_t *res = NULL;
    switch (VALUE_FUNC_ARITY(f)) {
        case 0:
            vm_trace_callbif(vm, f, NULL);
            res = elo_apply0(f, vm->denv);
            break;
        case 1: {
            value_t *arg1 = (value_t *)stack_pop(vm->stack);
            vm_trace_callbif(vm, f, arg1, NULL);
            res = elo_apply1(f, vm->denv, arg1);
        }
        break;
        case 2: {
            value_t *arg2 = (value_t *)stack_pop(vm->stack);
            value_t *arg1 = (value_t *)stack_pop(vm->stack);
            vm_trace_callbif(vm, f, arg1, arg2, NULL);
            res = elo_apply2(f, vm->denv, arg1, arg2);
        }
        break;
        default :
            fprintf(stderr, "Unsupported arity of bif: %d\n", VALUE_FUNC_ARITY(f));
            exit(0);
    }
    vm_trace_retbif(vm, f, res);
    stack_push(vm->stack, res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x357f
jmp 0x3568
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x35ad
jmp 0x3572
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x35f4
jmp 0x3652
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x39e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq %rax, -0x18(%rbp)
jmp 0x3678
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x9700
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x39e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, -0x18(%rbp)
jmp 0x3678
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x9700
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x9700
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x39e0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movq %rax, -0x18(%rbp)
jmp 0x3678
movq 0xb99f(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x6bd8(%rip), %rsi      # 0xa242
movb $0x0, %al
callq 0x20c0
xorl %edi, %edi
callq 0x2120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3bf0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9580
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/vm.c
// Function: vm_trace_callucf
static void vm_trace_callucf(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));
    for (int i = VALUE_FUNC_ARITY(f) - 1; i >= 0; i--) {
        value_t *arg = (value_t *)stack_nth(vm->stack, i);
        value_print(arg, TRACE_OUTPUT);
        if (i > 0)
            fprintf(TRACE_OUTPUT, ", ");
    }
    fprintf(TRACE_OUTPUT, ")\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3c80
cmpl $0x0, %eax
jne 0x36d3
jmp 0x377e
movq -0x8(%rbp), %rdi
callq 0x3d00
movq 0xb8ed(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x6b66(%rip), %rsi      # 0xa260
movb $0x0, %al
callq 0x20c0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x3766
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x96d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0xb89d(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
cmpl $0x0, -0x1c(%rbp)
jle 0x3759
movq 0xb888(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x6b17(%rip), %rsi      # 0xa269
movb $0x0, %al
callq 0x20c0
jmp 0x375b
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x370e
movq 0xb863(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x6af5(%rip), %rsi      # 0xa26c
movb $0x0, %al
callq 0x20c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/vm.c
// Function: vm_save
static void vm_save(vm_t *vm, ins_t *ins, value_t *_func_)
{
    /* 保存环境信息 */
    stack_push(vm->sys_stack, vm->denv);
    stack_push(vm->sys_stack, vm->env);
    /* 保存指令信息 */
    stack_push(vm->sys_stack, ins);
    /* 保存指令指针 */
    stack_push(vm->sys_stack, vm->ip);
    /* 保存上一个被调用的函数对象 */
    stack_push(vm->sys_stack, _func_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9580
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9700
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9700
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9700
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9700
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/vm.c
// Function: vm_value_print
static void vm_value_print(vm_t *vm, value_t *object)
{
    if (object->kind == VALUE_FUNCTION && VALUE_FUNC_ISCMP(object))
        vm_value_function_print(vm, object);
    else {
        value_print(object, stdout);
        fputc('\n', stdout);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x3952
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x3952
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3d50
jmp 0x3979
movq -0x10(%rbp), %rdi
movq 0xb673(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
movq 0xb664(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x3a1b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3c80
cmpl $0x0, %eax
jne 0x3a62
jmp 0x3bda
movq -0x8(%rbp), %rdi
callq 0x3d00
movq 0xb55e(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x67d7(%rip), %rsi      # 0xa260
movb $0x0, %al
callq 0x20c0
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x3aef
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x3b0c
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3bc2
movq -0x38(%rbp), %rdi
movq 0xb4a0(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
leaq -0x30(%rbp), %rax
movq %rax, -0x118(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x10c(%rbp)
cmpl $0x28, %eax
ja 0x3b73
movq -0x118(%rbp), %rcx
movl -0x10c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x120(%rbp)
jmp 0x3b90
movq -0x118(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3bbd
movq 0xb424(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x66b3(%rip), %rsi      # 0xa269
movb $0x0, %al
callq 0x20c0
jmp 0x3b1a
movq 0xb407(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x6699(%rip), %rsi      # 0xa26c
movb $0x0, %al
callq 0x20c0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3c80
cmpl $0x0, %eax
jne 0x3c24
jmp 0x3c79
movq -0x8(%rbp), %rdi
callq 0x3d00
movq 0xb39c(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq 0x6664(%rip), %rsi      # 0xa2af
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
movq 0xb373(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
movq 0xb364(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/vm.c
// Function: vm_value_function_print
static void vm_value_function_print(vm_t *vm, value_t *object)
{
    ins_t *ins = VALUE_UCF_CODE(object);
    int i = 0;
    while (i < ins_length(ins)) {
        bytecode_t *bc = ins_ref(ins, i);
        fprintf(stdout, "[%d]\t", i);
        bc_print(bc, stdout);
        fputc('\n', stdout);
        i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3ddf
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x9730
movq %rax, -0x28(%rbp)
movq 0xb237(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0x651b(%rip), %rsi      # 0xa2c1
movb $0x0, %al
callq 0x20c0
movq -0x28(%rbp), %rdi
movq 0xb218(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x64d0
movq 0xb209(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d73
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x6130
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl %esi, %edi
callq 0x63e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x63a0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x6430
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq 0xab42(%rip), %rax      # 0xf2f0
jae 0x4843
movslq -0xc(%rbp), %rcx
leaq 0xa931(%rip), %rax      # 0xf0f0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x4808
callq 0x94a0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x28(%rbp), %rsi
callq 0x2780
movq %rax, -0x20(%rbp)
jmp 0x4820
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x2440
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x7ea0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x47a3
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x20d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
callq 0x7d70
movq %rax, %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0x44a1(%rip), %rdi      # 0x8d30
leaq 0x451a(%rip), %rsi      # 0x8db0
callq 0x8a80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x4473(%rip), %rdi      # 0x8d20
leaq 0x44dc(%rip), %rsi      # 0x8d90
callq 0x8a80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x7d70
movq %rax, %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x48f0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_initbif
static void interp_initbif(interp_t *interp)
{
    int i = 0;
    while (i < prims_num) {
        prim_t *p = &prims[i];
        if (!p->is_compiled)
            interp_setbif(interp, p->name, p->func_ptr, p->arity);
        i++;
    }

    interp_setbis(interp, "set", bis_set);
    interp_setbis(interp, "if", bis_if);
    interp_setbis(interp, "begin", bis_begin);
    interp_setbis(interp, "lambda", bis_lambda);
    interp_setbis(interp, "dset", bis_dset);
    interp_setbis(interp, "dget", bis_dget);
    interp_setbis(interp, "define", bis_define);
    interp_setbis(interp, "&", bis_refof);
    interp_setbis(interp, "valof", bis_valof);
    interp_setbis(interp, "trace", bis_trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
leaq 0xa9e2(%rip), %rcx      # 0xf2f0
cmpq (%rcx), %rax
jae 0x495d
movslq -0xc(%rbp), %rcx
leaq 0xa7d2(%rip), %rax      # 0xf0f0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4952
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
callq 0x4d30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4903
movq -0x8(%rbp), %rdi
leaq 0x5a83(%rip), %rsi      # 0xa3eb
leaq 0x441(%rip), %rdx       # 0x4db0
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a5b(%rip), %rsi      # 0xa3da
leaq 0x53a(%rip), %rdx       # 0x4ec0
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a47(%rip), %rsi      # 0xa3dd
leaq 0x5f3(%rip), %rdx       # 0x4f90
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a36(%rip), %rsi      # 0xa3e3
leaq 0x69c(%rip), %rdx       # 0x5050
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a26(%rip), %rsi      # 0xa3ea
leaq 0x6f5(%rip), %rdx       # 0x50c0
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a14(%rip), %rsi      # 0xa3ef
leaq 0x78e(%rip), %rdx       # 0x5170
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x5a02(%rip), %rsi      # 0xa3f4
leaq 0x827(%rip), %rdx       # 0x5220
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x59f2(%rip), %rsi      # 0xa3fb
leaq 0x8a0(%rip), %rdx       # 0x52b0
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x59dd(%rip), %rsi      # 0xa3fd
leaq 0x939(%rip), %rdx       # 0x5360
callq 0x4d70
movq -0x8(%rbp), %rdi
leaq 0x59cc(%rip), %rsi      # 0xa403
leaq 0x9f2(%rip), %rdx       # 0x5430
callq 0x4d70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4, %eax
ja 0x4b05
movq -0x28(%rbp), %rax
leaq 0x5922(%rip), %rcx      # 0xa3a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4b40
movl %eax, -0x4(%rbp)
jmp 0x4b2d
cmpq $0x0, -0x20(%rbp)
je 0x4ac0
xorl %edi, %edi
callq 0x26e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x4b2d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c90
movl %eax, -0x4(%rbp)
jmp 0x4b2d
cmpq $0x0, -0x20(%rbp)
je 0x4afc
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x26e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x4b2d
movq 0xa4ec(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x58a0(%rip), %rsi      # 0xa3bc
movb $0x0, %al
callq 0x20c0
movl $0x1, %edi
callq 0x2120
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_execute_cons
static value_kind_t interp_execute_cons(interp_t *interp, ast_t *ast, value_t **value)
{
    ast_t *op = AST_CONS_CAR(ast);
    if (op->kind != AST_IDENTIFIER) {
        if (value != NULL)
            *value = value_error_newf("Line %d, column %d: The first element must be identifier", ast->line, ast->column);
        return VALUE_ERROR;
    }

    char *name = AST_IDENT_NAME(op);
    syntax_t *bis = interp_getbis(interp, name);
    if (bis != NULL)
        return interp_execute_syntax(interp, bis, AST_CONS_CDR(ast), value);

    value_t *op_value = NULL;
    value_kind_t kind = interp_execute(interp, op, &op_value);
    if (kind == VALUE_ERROR) {
        if (value != NULL)
            *value = op_value;
        return kind;
    }

    if (kind != VALUE_FUNCTION) {
        if (value != NULL)
            *value = value_error_newf("Line %d, column %d: The first element must evaluated to a function", ast->line, ast->column);
        return VALUE_ERROR;
    }

    return interp_execute_function(interp, op_value, AST_CONS_CDR(ast), value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x4ba2
cmpq $0x0, -0x20(%rbp)
je 0x4b96
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x5916(%rip), %rdi      # 0xa49b
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x4c7e
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5590
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x4bea
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x55c0
movl %eax, -0x4(%rbp)
jmp 0x4c7e
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a50
movl %eax, -0x44(%rbp)
cmpl $0x2, -0x44(%rbp)
jne 0x4c26
cmpq $0x0, -0x20(%rbp)
je 0x4c1e
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4c7e
cmpl $0x4, -0x44(%rbp)
je 0x4c62
cmpq $0x0, -0x20(%rbp)
je 0x4c59
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x588c(%rip), %rdi      # 0xa4d4
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x4c7e
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x5600
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_execute_ident
static value_kind_t interp_execute_ident(interp_t *interp, ast_t *ast, value_t **value)
{
    char *name = AST_IDENT_NAME(ast);
    value_t *val = env_get(interp->env, name);
    if (val != NULL) {
        if (value != NULL)
            *value = val;
        return val->kind;
    } else {
        if (value != NULL)
            *value = value_error_newf("Line %d, column %d: Can't find value of `%s'", ast->line, ast->column, name);
        return VALUE_ERROR;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x80f0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4cec
cmpq $0x0, -0x20(%rbp)
je 0x4ce1
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d24
cmpq $0x0, -0x20(%rbp)
je 0x4d1d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x28(%rbp), %rcx
leaq 0x56fd(%rip), %rdi      # 0xa409
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x4e1e
cmpq $0x0, -0x20(%rbp)
je 0x4e10
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4eb3
movq -0x28(%rbp), %rdi
callq 0x8640
cmpl $0x0, %eax
je 0x4e80
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x4e6f
cmpq $0x0, -0x20(%rbp)
je 0x4e64
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4eb3
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x4e98
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x5530
cmpq $0x0, -0x20(%rbp)
je 0x4eaa
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)