LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %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 -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x4f3f
cmpq $0x0, -0x20(%rbp)
je 0x4f34
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f7c
movq -0x40(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x4f68
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4f68
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a50
movl %eax, -0x4(%rbp)
jmp 0x4f7c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: bis_begin
static value_kind_t bis_begin(interp_t *interp, ast_t *body, value_t **result)
{
    while (body->kind == AST_CONS && AST_CONS_CDR(body)->kind != AST_END_OF_CONS) {
        ast_t *expr = AST_CONS_CAR(body);
        value_t *v = NULL;
        if (interp_execute(interp, expr, &v) == VALUE_ERROR) {
            if (result != NULL)
                *result = v;
            return v->kind;
        }
        body = AST_CONS_CDR(body);
    }
    return interp_execute(interp, AST_CONS_CAR(body), result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x31(%rbp)
jne 0x4fc3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, (%rax)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4fcc
jmp 0x5021
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x5013
cmpq $0x0, -0x20(%rbp)
je 0x5008
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5039
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4fa4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x85d0
movl %eax, %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
callq 0x27e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x50b2
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %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 0x512b
cmpq $0x0, -0x20(%rbp)
je 0x5120
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5162
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x7ea0
cmpq $0x0, -0x20(%rbp)
je 0x5159
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,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x80f0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x51d8
cmpq $0x0, -0x20(%rbp)
je 0x51cd
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5210
cmpq $0x0, -0x20(%rbp)
je 0x5209
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x30(%rbp), %rcx
leaq 0x5211(%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 $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x5190(%rip), %rdi      # 0xa3e3
callq 0x8390
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x8330
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x8370
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8330
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8330
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4db0
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %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, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x530f
cmpq $0x0, -0x20(%rbp)
je 0x5306
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x5141(%rip), %rdi      # 0xa436
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x534c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x8240
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5345
movq -0x30(%rbp), %rdi
callq 0x2710
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x6, -0x4(%rbp)
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: 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
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, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x53bb
cmpq $0x0, -0x20(%rbp)
je 0x53b0
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5423
movq -0x30(%rbp), %rax
cmpl $0x6, (%rax)
je 0x53fa
cmpq $0x0, -0x20(%rbp)
je 0x53f1
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x508d(%rip), %rdi      # 0xa46d
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x5423
cmpq $0x0, -0x20(%rbp)
je 0x5413
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -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_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 %rbp
movq %rsp, %rbp
subq $0x60, %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 $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x548e
cmpq $0x0, -0x20(%rbp)
je 0x5480
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x5526
movq -0x30(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x550b
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x54be
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x2b30
movq %rax, -0x38(%rbp)
jmp 0x54f6
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2070
leaq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rcx
movl $0x20, %esi
leaq 0x4c2c(%rip), %rdx      # 0xa10e
movb $0x0, %al
callq 0x2050
leaq -0x60(%rbp), %rdi
callq 0x2b30
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x8b30
cmpq $0x0, -0x20(%rbp)
je 0x551d
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_execute_function
static value_kind_t interp_execute_function(interp_t *interp, value_t *f, ast_t *args, value_t **value)
{
    int arity = VALUE_FUNC_ARITY(f);
    int nargs = ast_cons_length(args);
    if (nargs != arity) {
        if (value != NULL)
            *value = value_error_newf("Line %d, column %d: Incorrect number of arguments. Expecting %d but get %d", args->line, args->column, arity, nargs);
        return VALUE_ERROR;
    }
    if (VALUE_FUNC_ISBIF(f))
        return interp_execute_bif(interp, f, args, value);
    else
        return interp_execute_udf(interp, f, args, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x85d0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x5673
cmpq $0x0, -0x28(%rbp)
je 0x566a
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
leaq 0x4ebe(%rip), %rdi      # 0xa517
movb $0x0, %al
callq 0x2570
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x56af
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5697
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x56c0
movl %eax, -0x4(%rbp)
jmp 0x56af
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5890
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_execute_udf
static value_kind_t interp_execute_udf(interp_t *interp, value_t *f, ast_t *args, value_t **value)
{
    env_t *new_env = env_new(VALUE_FUNC_ENV(f));
    value_t *err = NULL;
    if (interp_bind_args(interp, VALUE_UDF_PARS(f), args, new_env, &err) == ERR) {
        if (value != NULL)
            *value = err;
        return err->kind;
    }
    interp_trace_calludf(interp, f, new_env);

    env_t *old_env = interp->env;
    interp->depth++;
    interp->env = new_env;
    interp->denv = env_new(interp->denv);
    value_kind_t kind = bis_begin(interp, VALUE_UDF_BODY(f), value);
    interp->depth--;
    interp->env = old_env;
    interp->denv = interp->denv->outer;
    interp_trace_retudf(interp, f, *value);
    return kind;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7d80
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0x5e80
cmpl $0x0, %eax
jne 0x5903
cmpq $0x0, -0x28(%rbp)
je 0x58f5
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x59ac
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5f60
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7d80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x4f90
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
callq 0x6090
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_execute_args
static int interp_execute_args(interp_t *interp, ast_t *args, vector_t **_vals, value_t **error)
{
    assert(_vals != NULL);
    assert(error != NULL);

    vector_t *vals = vector_new();
    while (args->kind != AST_END_OF_CONS) {
        ast_t *ele = AST_CONS_CAR(args);
        value_t *val = NULL;
        if (interp_execute(interp, ele, &val) == VALUE_ERROR) {
            *error = val;
            return ERR;
        }
        vector_push(vals, (intptr_t)val);
        args = AST_CONS_CDR(args);
    }
    *_vals = vals;
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x59e1
jmp 0x5a00
leaq 0x4ba6(%rip), %rdi      # 0xa58e
leaq 0x4bad(%rip), %rsi      # 0xa59c
movl $0x145, %edx            # imm = 0x145
leaq 0x4baa(%rip), %rcx      # 0xa5a5
callq 0x2060
cmpq $0x0, -0x28(%rbp)
je 0x5a09
jmp 0x5a28
leaq 0x4bdb(%rip), %rdi      # 0xa5eb
leaq 0x4b85(%rip), %rsi      # 0xa59c
movl $0x146, %edx            # imm = 0x146
leaq 0x4b82(%rip), %rcx      # 0xa5a5
callq 0x2060
callq 0x94a0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x5a93
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x5a78
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5aa5
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9580
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5a31
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %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 0x5db0
cmpl $0x0, %eax
jne 0x5d17
jmp 0x5d9c
movq -0x8(%rbp), %rdi
callq 0x5e30
movq 0x92a9(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x48c2(%rip), %rsi      # 0xa5f9
movb $0x0, %al
callq 0x20c0
movq 0x928b(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x4377(%rip), %rsi      # 0xa0cd
movb $0x0, %al
callq 0x20c0
movq 0x926c(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x4548(%rip), %rsi      # 0xa2b6
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
movq 0x9250(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
movq 0x9241(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_bind_args
static int interp_bind_args(interp_t *interp, ast_t *pars, ast_t *exprs, env_t *env, value_t **error)
{
    assert(error != NULL);
    while (pars->kind == AST_CONS) {
        ast_t *par = AST_CONS_CAR(pars);
        ast_t *expr = AST_CONS_CAR(exprs);
        value_t *val = NULL;
        if (interp_execute(interp, expr, &val) == VALUE_ERROR) {
            *error = val;
            return ERR;
        }
        env_set(env, AST_IDENT_NAME(par), val);
        pars = AST_CONS_CDR(pars);
        exprs = AST_CONS_CDR(exprs);
    }
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5ea5
jmp 0x5ec4
leaq 0x473f(%rip), %rdi      # 0xa5eb
leaq 0x46e9(%rip), %rsi      # 0xa59c
movl $0x182, %edx            # imm = 0x182
leaq 0x4771(%rip), %rcx      # 0xa630
callq 0x2060
jmp 0x5ec6
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5f4e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x4a50
cmpl $0x2, %eax
jne 0x5f19
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5f55
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq -0x48(%rbp), %rdx
callq 0x7ea0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5ec6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/interp.c
// Function: interp_trace_calludf
static void interp_trace_calludf(interp_t *interp, value_t *f, env_t *env)
{
    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);
    ast_t *pars = VALUE_UDF_PARS(f);
    while (pars->kind != AST_END_OF_CONS) {
        ast_t *par = AST_CONS_CAR(pars);
        value_t *arg = env_get(env, AST_IDENT_NAME(par));
        value_print(arg, TRACE_OUTPUT);
        pars = AST_CONS_CDR(pars);
        if (pars->kind != AST_END_OF_CONS)
            fprintf(TRACE_OUTPUT, ", ");
    }
    fprintf(TRACE_OUTPUT, ")\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 0x5db0
cmpl $0x0, %eax
jne 0x5f97
jmp 0x6084
movq -0x8(%rbp), %rdi
callq 0x5e30
movq 0x9029(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x4642(%rip), %rsi      # 0xa5f9
movb $0x0, %al
callq 0x20c0
movq 0x900b(%rip), %rax      # 0xefd0
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x40f7(%rip), %rsi      # 0xa0cd
movb $0x0, %al
callq 0x20c0
movq 0x8fec(%rip), %rax      # 0xefd0
movq (%rax), %rsi
movl $0x28, %edi
callq 0x2090
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x606c
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x80f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq 0x8f9b(%rip), %rax      # 0xefd0
movq (%rax), %rsi
callq 0x2860
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
je 0x606a
movq 0x8f77(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x4206(%rip), %rsi      # 0xa269
movb $0x0, %al
callq 0x20c0
jmp 0x5ffd
movq 0x8f5d(%rip), %rax      # 0xefd0
movq (%rax), %rdi
leaq 0x41ef(%rip), %rsi      # 0xa26c
movb $0x0, %al
callq 0x20c0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x7, %edi
callq 0x6100
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x9, %edi
callq 0x6100
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0xb, %edi
callq 0x6100
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x67ad
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x9730
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
je 0x6738
jmp 0x6757
leaq 0x3f99(%rip), %rdi      # 0xa6d8
leaq 0x3fac(%rip), %rsi      # 0xa6f2
movl $0x106, %edx            # imm = 0x106
leaq 0x3fab(%rip), %rcx      # 0xa6fd
callq 0x2060
movq -0x20(%rbp), %rax
cmpl $0x10, (%rax)
je 0x677e
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x67c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
jmp 0x6791
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x6830
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x2090
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x670a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x67fa
movq -0x10(%rbp), %rsi
movl $0x9, %edi
callq 0x2090
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x67db
cmpl $-0x1, -0x8(%rbp)
je 0x6815
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0x3f1b(%rip), %rsi      # 0xa729
movb $0x0, %al
callq 0x20c0
movq -0x10(%rbp), %rsi
movl $0x9, %edi
callq 0x2090
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/bytecode.c
// Function: ins_push_print
static void ins_push_print(bytecode_t *bc, FILE *output, int indent, int index)
{
    value_t *object = BC_PUSH_PTR(bc);
    if (object->kind == VALUE_FUNCTION && VALUE_FUNC_ISCMP(object))
        ins_push_ucf_print(object, output, indent, index);
    else {
        ins_indent_print(indent, index, output);
        bc_print(bc, output);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x687a
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x687a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x68a0
jmp 0x6896
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x67c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x64d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/bytecode.c
// Function: ins_push_ucf_print
static void ins_push_ucf_print(value_t *ucf, FILE *output, int indent, int index)
{
    ins_indent_print(indent, index, output);
    fprintf(output, "BC_PUSH #< ; This is a function\n");
    ins_t *ins = VALUE_UCF_CODE(ucf);
    ins_pretty_print(ins, output, indent + 1);
    ins_indent_print(indent, -1, output);
    fprintf(output, "        >");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x67c0
movq -0x10(%rbp), %rdi
leaq 0x3e5e(%rip), %rsi      # 0xa72e
movb $0x0, %al
callq 0x20c0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x66f0
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x67c0
movq -0x10(%rbp), %rdi
leaq 0x3e3d(%rip), %rsi      # 0xa74f
movb $0x0, %al
callq 0x20c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x20d0
movq %rax, -0x8(%rbp)
callq 0x9170
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%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, %rdi
callq 0x4790
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x239b(%rip), %rdi      # 0x8d30
leaq 0x2414(%rip), %rsi      # 0x8db0
callq 0x8a80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq 0x237d(%rip), %rdi      # 0x8d30
leaq 0x23f6(%rip), %rsi      # 0x8db0
callq 0x8a80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
leaq 0x3a08(%rip), %rsi      # 0xa3dd
leaq 0x124(%rip), %rdx       # 0x6b00
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x39ff(%rip), %rsi      # 0xa3eb
leaq 0x1bd(%rip), %rdx       # 0x6bb0
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x39d7(%rip), %rsi      # 0xa3da
leaq 0x356(%rip), %rdx       # 0x6d60
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x39c9(%rip), %rsi      # 0xa3e3
leaq 0x47f(%rip), %rdx       # 0x6ea0
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x39be(%rip), %rsi      # 0xa3ef
leaq 0x588(%rip), %rdx       # 0x6fc0
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x39a2(%rip), %rsi      # 0xa3ea
leaq 0x5c1(%rip), %rdx       # 0x7010
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x3995(%rip), %rsi      # 0xa3f4
leaq 0x63a(%rip), %rdx       # 0x70a0
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x3985(%rip), %rsi      # 0xa3fb
leaq 0x6b3(%rip), %rdx       # 0x7130
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x3970(%rip), %rsi      # 0xa3fd
leaq 0x72c(%rip), %rdx       # 0x71c0
callq 0x6ad0
movq -0x8(%rbp), %rdi
leaq 0x395f(%rip), %rsi      # 0xa403
leaq 0x785(%rip), %rdx       # 0x7230
callq 0x6ad0
movq -0x8(%rbp), %rax
movl $0x0, (%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/compiler.c
// Function: compiler_do_begin
static int compiler_do_begin(compiler_t *comp, ast_t *body, ins_t *ins)
{
    while (body->kind == AST_CONS && AST_CONS_CDR(body)->kind != AST_END_OF_CONS) {
        ast_t *expr = AST_CONS_CAR(body);
        if (compiler_do(comp, expr, ins) == ERR)
            return ERR;
        ins_push(ins, bc_pop_new());
        body = AST_CONS_CDR(body);
    }
    return compiler_do(comp, AST_CONS_CAR(body), ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, (%rcx)
movb %al, -0x29(%rbp)
jne 0x6b33
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, (%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x6b3c
jmp 0x6b8e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x6b67
movl $0x0, -0x4(%rbp)
jmp 0x6ba6
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6390
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b14
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_if
static int compiler_do_if(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *pred = AST_CONS_CAR(body);
    ast_t *p = AST_CONS_CAR( AST_CONS_CDR(body) );
    ast_t *e = AST_CONS_CAR( AST_CONS_CDR( AST_CONS_CDR(body) ) );
    if (compiler_do(comp, pred, ins) == ERR)
        return ERR;
    bytecode_t *label_else = compiler_mklabel(comp);
    bytecode_t *label_end = compiler_mklabel(comp);
    ins_push(ins, bc_fjump_new(label_else));
    if (compiler_do(comp, p, ins) == ERR)
        return ERR;
    ins_push(ins, bc_jump_new(label_end));
    ins_push(ins, label_else);
    if (compiler_do(comp, e, ins) == ERR)
        return ERR;
    ins_push(ins, label_end);
    ins_push(ins, bc_nope_new());
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x6dc6
movl $0x0, -0x4(%rbp)
jmp 0x6e92
movq -0x10(%rbp), %rdi
callq 0x76a0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x76a0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6210
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x6e1c
movl $0x0, -0x4(%rbp)
jmp 0x6e92
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6300
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9580
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x6e65
movl $0x0, -0x4(%rbp)
jmp 0x6e92
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9580
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x6380
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_lambda
static int compiler_do_lambda(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *pars = AST_CONS_CAR(body);
    body = AST_CONS_CDR(body);
    int arity = compiler_extend_scope(comp, pars);
    ins_t *code = ins_new();
    ins_push(code, bc_args_new(arity));
    if (compiler_do_begin(comp, body, code) == ERR) {
        compiler_exit_scope(comp);
        return ERR;
    }
    ins_push(code, bc_return_new());
    compiler_exit_scope(comp);
    code = compiler_assemby(comp, code);
    value_t *f = value_ucf_new(arity, code);
    ins_push(ins, bc_push_new(f));
    ins_push(ins, bc_func_new());
    return OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %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 %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7700
movl %eax, -0x2c(%rbp)
callq 0x94a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x2c(%rbp), %edi
callq 0x6130
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x6b00
cmpl $0x0, %eax
jne 0x6f2c
movq -0x10(%rbp), %rdi
callq 0x7790
movl $0x0, -0x4(%rbp)
jmp 0x6fac
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x6430
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x10(%rbp), %rdi
callq 0x7790
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7670
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
callq 0x2780
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0x63b0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x6250
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_dset
static int compiler_do_dset(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *var = AST_CONS_CAR(body);
    ast_t *expr = AST_CONS_CAR( AST_CONS_CDR(body) );
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ins_push(ins, bc_dset_new(AST_IDENT_NAME(var)));
    return OK;
}

// Assembly:
pushq %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 -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x705f
movl $0x0, -0x4(%rbp)
jmp 0x708a
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x61e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_define
static int compiler_do_define(compiler_t *comp, ast_t *body, ins_t *ins)
{
    /* 构造符合set语法的表达式并再次编译 */
    ast_t *name = AST_CONS_CAR(body);
    ast_t *lpart = AST_CONS_CDR(body);
    ast_t *lexpr = ast_cons_new(ast_ident_new("lambda"), lpart);
    ast_t *sexpr = ast_cons_new(name, ast_cons_new(lexpr, ast_eoc_new()));
    return compiler_do_set(comp, sexpr, ins);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x3310(%rip), %rdi      # 0xa3e3
callq 0x8390
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x8330
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x8370
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x8330
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x8330
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6bb0
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_refof
static int compiler_do_refof(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *var = AST_CONS_CAR(body);
    if (var->kind != AST_IDENTIFIER) {
        string_printf(comp->error, "Line %d, column %d: Operand of & must be an identifier", var->line, var->column);
        return ERR;
    }
    ins_push(ins, bc_addr_new(AST_IDENT_NAME(var)));
    return OK;
}

// Assembly:
pushq %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, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x7186
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x32c0(%rip), %rsi      # 0xa436
movb $0x0, %al
callq 0x9340
movl $0x0, -0x4(%rbp)
jmp 0x71b1
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x60c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_valof
static int compiler_do_valof(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *expr = AST_CONS_CAR(body);
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ins_push(ins, bc_valof_new());
    return OK;
}

// 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, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x71ff
movl $0x0, -0x4(%rbp)
jmp 0x721f
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x64c0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Liutos[P]Eloquent/compiler.c
// Function: compiler_do_trace
static int compiler_do_trace(compiler_t *comp, ast_t *body, ins_t *ins)
{
    ast_t *expr = AST_CONS_CAR(body);
    if (compiler_do(comp, expr, ins) == ERR)
        return ERR;
    ident_t *id = NULL;
    if (expr->kind == AST_IDENTIFIER)
        id = ident_intern(AST_IDENT_NAME(expr));
    ins_push(ins, bc_trace_new(id));
    return OK;
}

// Assembly:
pushq %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 -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7310
cmpl $0x0, %eax
jne 0x726f
movl $0x0, -0x4(%rbp)
jmp 0x72b8
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x7294
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x2b30
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6490
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x9580
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)