LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_if
ast_node_if* parse_if(parse_state* state, scope* sc) {
    parse_eat(state, _IF);
    parse_eat(state, _LPAREN);
    ast_node* expr = parse_expr(state, sc);
    parse_eat(state, _RPAREN);
    parse_eat(state, _LBRACE);
    ast_node_compound* body =  parse_compound(state, sc);
    parse_eat(state, _RBRACE);

    ast_node_else* elsenode = (void*)0;

    if (state->current_token->type == _ELSE)
        elsenode = parse_else(state, sc);

    ast_node_if* if_ast = init_ast_node_if(
        state->current_token,
        expr,
        body,
        elsenode
    );

    ast_node_set_scope((ast_node*) if_ast, (struct scope*) sc);

    return if_ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x12
popq %rsi
callq 0x315c
pushq $0xc
popq %rsi
movq %r14, %rdi
callq 0x315c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3244
movq %rax, %r15
pushq $0xd
popq %rsi
movq %r14, %rdi
callq 0x315c
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x315c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34c9
movq %rax, %r12
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x315c
movq 0x8(%r14), %rdi
cmpl $0x13, (%rdi)
jne 0x368c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x358c
movq %rax, %rcx
movq 0x8(%r14), %rdi
jmp 0x368e
xorl %ecx, %ecx
movq %r15, %rsi
movq %r12, %rdx
callq 0x154c
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_variable
ast_node_variable* parse_variable(parse_state* state, scope* sc) {
    ast_node_variable* var = init_ast_node_variable(state->current_token, (void*)0);
    parse_eat(state, _ID);

    ast_node_set_scope((ast_node*) var, (struct scope*) sc);

    return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
xorl %esi, %esi
callq 0x167c
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x315c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_function_call
ast_node_function_call* parse_function_call(parse_state* state, scope* sc) {
    token* tok = state->current_token;
    parse_eat(state, _FUNCTION_CALL);
    ss_vector* args = ss_init_vector(sizeof(ast_node));

    parse_eat(state, _LPAREN);

    if (state->current_token->type != _RPAREN) {
        ss_vector_append(args, (ast_node*) parse_expr(state, sc));

        while (state->current_token->type == _COMMA) {
            parse_eat(state, _COMMA);
            ss_vector_append(args, (ast_node*) parse_expr(state, sc));
        }
    }

    parse_eat(state, _RPAREN);

    ast_node_function_call* call = init_ast_node_function_call(
        tok,
        args
    );

    ast_node_set_scope((ast_node*)call, (struct scope*) sc);

    return call;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
pushq $0x1c
popq %rsi
callq 0x315c
pushq $0x18
popq %rdi
callq 0x4198
movq %rax, %r12
pushq $0xc
popq %rsi
movq %r15, %rdi
callq 0x315c
movq 0x8(%r15), %rax
cmpl $0xd, (%rax)
jne 0x376a
pushq $0xd
popq %rsi
movq %r15, %rdi
callq 0x315c
movq %r14, %rdi
movq %r12, %rsi
callq 0x14dc
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %r13
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3244
movq %r12, %rdi
movq %rax, %rsi
callq 0x41c7
movq 0x8(%r15), %rax
cmpl $0x10, (%rax)
jne 0x3734
movq %r15, %rdi
movl %r13d, %esi
callq 0x315c
jmp 0x376e
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_component
ast_node_component* parse_component(parse_state* state, scope* sc) {
    parse_eat(state, _TYPE_COMPONENT);

    sc = init_scope();
    
    token* name = state->current_token;
    parse_eat(state, _ID);

    ss_vector* deps = ss_init_vector(sizeof(token));

    if (state->current_token->type == _USE) {
        parse_eat(state, _USE);
        ss_vector_append(deps, state->current_token);
        parse_eat(state, _ID); 

        while (state->current_token->type == _COMMA) {
            parse_eat(state, _COMMA);
            parse_eat(state, _ID); 
            ss_vector_append(deps, state->current_token);
        }
    }

    parse_eat(state, _LBRACE);
    ast_node_compound* body = parse_compound(state, sc);
    ast_node_set_scope((ast_node*)body, (struct scope*)sc);

    parse_eat(state, _RBRACE);

    ast_node_component* component = init_ast_node_component(
        name,
        name,
        body,
        deps
    );
    
    //ast_node_set_scope((ast_node*)component, (struct scope*)sc);

    return component;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2f
popq %rsi
callq 0x315c
xorl %eax, %eax
callq 0x3fb0
movq %rax, %r15
movq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x315c
pushq $0x10
popq %rdi
callq 0x4198
movq %rax, %r12
movq 0x8(%rbx), %rax
cmpl $0xb, (%rax)
jne 0x39d3
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x315c
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x41c7
pushq $0x1
popq %r13
movq %rbx, %rdi
movl %r13d, %esi
callq 0x315c
pushq $0x10
popq %r14
movq 0x8(%rbx), %rax
cmpl $0x10, (%rax)
jne 0x39d3
movq %rbx, %rdi
movl %r14d, %esi
callq 0x315c
movq %rbx, %rdi
movl %r13d, %esi
callq 0x315c
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0x41c7
jmp 0x39a6
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x315c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34c9
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x12d2
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x315c
movq -0x30(%rbp), %rdi
movq %rdi, %rsi
movq %r14, %rdx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1398
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_term
ast_node* parse_term(parse_state* state, scope* sc) {
    token* tok = (void*)0;

    ast_node* node = parse_factor(state, sc);

    if (state->current_token->type == _EQUALS) {
        token* tok = state->current_token;
        parse_eat(state, _EQUALS);
        ast_node* assign_node = (ast_node*)  init_ast_node_binop(tok, node, parse_expr(state, sc));
        ast_node_set_scope((ast_node*) assign_node, (struct scope*) sc);
        return assign_node;
    } 

    while (
            state->current_token->type == _OP_MULTIPLY ||
            state->current_token->type == _OP_DIVIDE
          ) {
        tok = state->current_token;

        if (tok->type == _OP_MULTIPLY) {
            parse_eat(state, _OP_MULTIPLY);
        } else if (tok->type == _OP_DIVIDE) {
            parse_eat(state, _OP_DIVIDE);
        }

        // this probably wont work since `node` is of pointer type ast_node*
        node = (ast_node*) init_ast_node_binop(tok, node, parse_factor(state, sc));
        ast_node_set_scope((ast_node*) node, (struct scope*) sc);
    }

    return (ast_node*) node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x379a
movq %rax, %r14
movq 0x8(%r15), %r12
movl (%r12), %eax
cmpl $0x1b, %eax
jne 0x3a86
pushq $0x1b
popq %rsi
movq %r15, %rdi
callq 0x315c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3244
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1318
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leal -0x7(%rax), %ecx
cmpl $0x1, %ecx
ja 0x3a7a
xorl %esi, %esi
cmpl $0x7, %eax
setne %sil
addl $0x7, %esi
movq %r15, %rdi
callq 0x315c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x379a
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1318
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq 0x8(%r15), %r12
movl (%r12), %eax
jmp 0x3a86
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_statement
ast_node* parse_statement(parse_state* state, scope* sc) {
    if (state->current_token->type == _INTERPRETER_INSTR) {
        return (ast_node*) parse_interpreter_instr(state, sc);
    } else if (state->current_token->type == _RETURN) {
        return (ast_node*) parse_return(state, sc);
    } else if (state->current_token->type == _TYPE_COMPONENT) {
        return (ast_node*) parse_component(state, sc);
    } else if (state->current_token->type == _IF) {
        return (ast_node*) parse_if(state, sc);
    } else if (state->current_token->type == _WHILE) {
        return (ast_node*) parse_while(state, sc);
    } else if (state->current_token->type == _FOREACH) {
        return (ast_node*) parse_foreach(state, sc);
    } else if (state->current_token->type == _DATA_TYPE) {
        return (ast_node*) parse_variable_definition(state, sc);
    } else if (state->current_token->type == _TYPE_FUNCTION) {
        return (ast_node*) parse_function_definition(state, sc);
    }  else if (state->current_token->type == _FUNCTION_CALL) {
        return (ast_node*) parse_function_call(state, sc);
    } else if (state->current_token->type == _ID || state->current_token->type == _INTEGER || state->current_token->type == _FLOAT) {
        return parse_expr(state, sc);
    } else {
        return (void*)0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movl (%rax), %eax
leal -0x1c(%rax), %ecx
cmpl $0xb, %ecx
jbe 0x3b0c
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x3b22
cmpl $0x4, %eax
je 0x3b50
cmpl $0x11, %eax
je 0x3b3e
cmpl $0x12, %eax
je 0x3b44
cmpl $0x2f, %eax
je 0x3b4a
cmpl $0x30, %eax
jne 0x3b28
popq %rbp
jmp 0x3c90
leaq 0x185d(%rip), %rax      # 0x5370
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rbp
jmp 0x36f5
popq %rbp
jmp 0x3244
xorl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x34dd
popq %rbp
jmp 0x3434
popq %rbp
jmp 0x3b56
popq %rbp
jmp 0x33f2
popq %rbp
jmp 0x360e
popq %rbp
jmp 0x3932
popq %rbp
jmp 0x3bde
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_interpreter_instr
ast_node_interpreter_instr* parse_interpreter_instr(parse_state* state, scope* sc) {
    token* tok = state->current_token;
    char* instruction_name = tok->value;

    // TODO: make this better, give the user some information about which
    // instruction name that was unknown.
    if (strcmp(instruction_name, "include") != 0)
        error_in_parser("Unknown instruction name");

    parse_eat(state, _INTERPRETER_INSTR);
    char* instruction_value = state->current_token->value;
    parse_eat(state, _STRING);

    ast_node_interpreter_instr* instr = init_ast_node_interpreter_instr(
        tok,
        instruction_name,
        instruction_value        
    );
    
    ast_node_set_scope((ast_node*) instr, (struct scope*)sc);

    return instr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq 0x8(%r14), %r15
leaq 0x1876(%rip), %rsi      # 0x53ef
movq %r15, %rdi
callq 0x10c0
testl %eax, %eax
je 0x3b91
leaq 0x186b(%rip), %rdi      # 0x53f7
callq 0x1abc
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x315c
movq 0x8(%r12), %rax
movq 0x8(%rax), %r13
pushq $0x3
popq %rsi
movq %r12, %rdi
callq 0x315c
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x15bc
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_variable_definition
ast_node_variable_definition* parse_variable_definition(parse_state* state, scope* sc) {
    char* data_type_name = state->current_token->value;
    int data_type = name_to_data_type(data_type_name);
    ast_node* value;

    parse_eat(state, _DATA_TYPE);

    if (data_type == _DATA_TYPE_VECTOR) {
        parse_eat(state, _LESS_THAN);
        //char* vector_data_type_name = state->current_token->value;
        parse_eat(state, _DATA_TYPE);
        //int vector_data_type = name_to_data_type(vector_data_type_name);
        parse_eat(state, _LARGER_THAN);
    }

    token* tok = state->current_token;
    parse_eat(state, _ID);

    if (state->current_token->type == _EQUALS) {
        parse_eat(state, _EQUALS);
        value = parse_expr(state, sc);
    } else {
        value = (ast_node*) init_ast_node_empty((void*)0);
    }

    ast_node_variable_definition* definition = init_ast_node_variable_definition(
        tok,
        data_type,
        value
    );

    ast_node_set_scope((ast_node*)definition, (struct scope*) sc);

    return definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x1798
movl %eax, %r14d
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x315c
cmpl $0x2e, %r14d
jne 0x3c31
pushq $0x16
popq %rsi
movq %r15, %rdi
callq 0x315c
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x315c
pushq $0x17
popq %rsi
movq %r15, %rdi
callq 0x315c
movq 0x8(%r15), %r12
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x315c
movq 0x8(%r15), %rax
cmpl $0x1b, (%rax)
jne 0x3c61
pushq $0x1b
popq %rsi
movq %r15, %rdi
callq 0x315c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3244
jmp 0x3c68
xorl %edi, %edi
callq 0x1444
movq %r12, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x16a8
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_function_definition
ast_node_function_definition* parse_function_definition(parse_state* state, scope* sc) {
    parse_eat(state, _TYPE_FUNCTION);

    char* data_type_name = state->current_token->value;
    int data_type = name_to_data_type(data_type_name);
    ast_node_compound* body;
    ss_vector* args = ss_init_vector(sizeof(ast_node));

    parse_eat(state, _DATA_TYPE);
    token* tok = state->current_token;
    parse_eat(state, _ID);

    if (state->current_token->type == _LPAREN) {
        parse_eat(state, _LPAREN);
       
        ss_vector_append(args, (ast_node*) parse_variable_definition(state, sc));

        while (state->current_token->type == _COMMA) {
            parse_eat(state, _COMMA);
            ss_vector_append(args, (ast_node*) parse_variable_definition(state, sc));
        }
    }

    parse_eat(state, _LBRACE);
    body = parse_compound(state, sc);
    parse_eat(state, _RBRACE);

    ast_node_function_definition* definition = init_ast_node_function_definition(
        tok,
        data_type,
        args,
        body 
    );

    ast_node_set_scope((ast_node*) definition, (struct scope*)sc);

    return definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x30
popq %rsi
callq 0x315c
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
callq 0x1798
movl %eax, -0x2c(%rbp)
pushq $0x18
popq %rdi
callq 0x4198
movq %rax, %r12
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x315c
movq 0x8(%r14), %r13
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x315c
movq 0x8(%r14), %rax
cmpl $0xc, (%rax)
jne 0x3d1b
pushq $0xc
popq %rsi
pushq $0x10
popq %r15
movq %r14, %rdi
callq 0x315c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3bde
movq %r12, %rdi
movq %rax, %rsi
callq 0x41c7
movq 0x8(%r14), %rax
cmpl $0x10, (%rax)
movl %r15d, %esi
je 0x3cf1
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x315c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34c9
movq %rax, %r15
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x315c
movq %r13, %rdi
movl -0x2c(%rbp), %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1508
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/parse.c
// Function: parse_statement_list
ss_vector* parse_statement_list(parse_state* state, scope* sc) {
    ss_vector* nodes = ss_init_vector(sizeof(ast_node));

    ss_vector_append(nodes, parse_statement(state, sc));

    while (state->current_token->type == _SEMI) {
        parse_eat(state, _SEMI);

        ast_node* next_statement = parse_statement(state, sc);

        if (!next_statement)
            break;

        ss_vector_append(nodes, next_statement);
    }

    return nodes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x4198
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ad3
movq %r15, %rdi
movq %rax, %rsi
callq 0x41c7
pushq $0x14
popq %r12
movq 0x8(%r14), %rax
cmpl $0x14, (%rax)
jne 0x3dd7
movq %r14, %rdi
movl %r12d, %esi
callq 0x315c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ad3
testq %rax, %rax
je 0x3dd7
movq %r15, %rdi
movq %rax, %rsi
callq 0x41c7
jmp 0x3da6
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/scope.c
// Function: init_scope
scope* init_scope() {
    scope* sc;
    sc = malloc(sizeof(scope));
    sc->variables = ss_init_vector(sizeof(ast_node_variable_definition));
    sc->functions = ss_init_vector(sizeof(ast_node_function_definition));
    sc->components = ss_init_vector(sizeof(ast_node_component));

    return sc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x18
popq %rdi
callq 0x10e0
movq %rax, %rbx
pushq $0x30
popq %rdi
callq 0x4198
movq %rax, (%rbx)
pushq $0x40
popq %rdi
callq 0x4198
movq %rax, 0x8(%rbx)
pushq $0x38
popq %rdi
callq 0x4198
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/scope.c
// Function: delete_variable_definition
void delete_variable_definition(scope* sc, char* name) {
    ast_node_variable_definition* definition = (void*)0;

    for (int i = 0; i < sc->variables->size; i++) {
        definition = (ast_node_variable_definition*) sc->variables->items[i];

        if (strcmp(definition->tok->value, name) == 0) {
            free(sc->variables->items[i]);
            sc->variables->size -=1;
        } else {
            definition = (void*)0;
        }
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq (%rdi), %r13
movq (%r13), %r14
xorl %r12d, %r12d
cmpq %r12, %r14
jbe 0x405a
movq 0x8(%r13), %rax
movq (%rax,%r12,8), %r15
movq 0x18(%r15), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x10c0
testl %eax, %eax
jne 0x4055
movq %r15, %rdi
callq 0x1030
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq (%r13), %r14
decq %r14
movq %r14, (%r13)
incq %r12
jmp 0x401a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/scope.c
// Function: get_variable_definition
ast_node_variable_definition* get_variable_definition(scope* sc, char* name) {
    ast_node_variable_definition* definition = (void*)0;

    for (int i = 0; i < sc->variables->size; i++) {
        definition = (ast_node_variable_definition*) sc->variables->items[i];

        if (strcmp(definition->tok->value, name) == 0) {
            break;
        } else {
            definition = (void*)0;
        }
    }

    return definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
movq (%r15), %r12
xorl %r13d, %r13d
cmpq %r13, %r12
jbe 0x40c5
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %r14
movq 0x18(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x10c0
incq %r13
testl %eax, %eax
jne 0x409f
jmp 0x40c8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/scope.c
// Function: get_function_definition
ast_node_function_definition* get_function_definition(scope* sc, char* name) {
    ast_node_function_definition* definition = (void*)0;

    for (int i = 0; i < sc->functions->size; i++) {
        definition = (ast_node_function_definition*) sc->functions->items[i];

        if (definition) {
            if (definition->tok) {
                if (definition->tok->value) {
        if (strcmp(definition->tok->value, name) == 0) {
            break;
        } else {
            definition = (void*)0;
        }
            }
        }
        }
    }

    return definition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %r15
movq (%r15), %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
cmpq %r13, %r12
jbe 0x4130
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x4128
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x412b
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x412b
movq %rbx, %rsi
callq 0x10c0
testl %eax, %eax
je 0x4130
xorl %r14d, %r14d
incq %r13
jmp 0x40f8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/scope.c
// Function: get_component
ast_node_component* get_component(scope* sc, char* name) {
    ast_node_component* component = (void*)0;

    for (int i = 0; i < sc->components->size; i++) {
        component = (ast_node_component*) sc->components->items[i];

        if (strcmp(component->tok->value, name) == 0) {
            break;
        } else {
            component = (void*)0;
        }
    }

    return component;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
movq (%r15), %r12
xorl %r13d, %r13d
cmpq %r13, %r12
jbe 0x4183
movq 0x8(%r15), %rax
movq (%rax,%r13,8), %r14
movq 0x18(%r14), %rax
movq 0x8(%rax), %rdi
movq %rbx, %rsi
callq 0x10c0
incq %r13
testl %eax, %eax
jne 0x415d
jmp 0x4186
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ss_vector.c
// Function: ss_init_vector
ss_vector* ss_init_vector(size_t item_size) {
    ss_vector* vector;
    vector = malloc(sizeof(ss_vector));
    vector->size = 0;
    vector->items = calloc(0, item_size);

    return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x10e0
movq %rax, %r14
andq $0x0, (%rax)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x10b0
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/ss_vector.c
// Function: ss_vector_free
void ss_vector_free(ss_vector* vec) {
    for (int i = 0; i < vec->size; i++)
        free(vec->items[i]);

    free(vec->items);
    free(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x8(%rbx), %rdi
cmpq %r14, (%rbx)
jbe 0x4224
movq (%rdi,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x420d
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/strutils.c
// Function: char_to_string
char* char_to_string(char c) {
    char* str;
    str = malloc(sizeof(char) * 2);
    str[0] = c;
    str[1] = '\0';

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x2
popq %rdi
callq 0x10e0
movb %bl, (%rax)
movb $0x0, 0x1(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/strutils.c
// Function: is_integer
int is_integer(char* str) {
    for (int i = 0; i < strlen(str); i++)
        if (!isdigit(str[i]))
            return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1090
movq %rax, %r14
xorl %eax, %eax
movq %rax, %r15
cmpq %rax, %r14
je 0x428c
callq 0x1170
movq (%rax), %rcx
movsbq (%rbx,%r15), %rdx
leaq 0x1(%r15), %rax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0x426c
xorl %eax, %eax
cmpq %r15, %r14
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/sebbekarlsson[P]cola/src/token.c
// Function: init_token
token* init_token(tokentype type, char* value) {
    token* tok;
    tok = malloc(sizeof(token));
    tok->type = type;
    tok->value = value;

    return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
pushq $0x10
popq %rdi
callq 0x10e0
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: print_msg
BEH_DECL(print_msg)
{
	CONS* text = map_get(MINE, ATOM("message"));

	DBUG_ENTER("print_msg");
	if (atomp(text)) {
		printf("%s", atom_str(text));
	}
	printf("%s\n", cons_to_str(WHAT));
	DBUG_RETURN;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r14
leaq 0x10c93(%rip), %rdi     # 0x13004
callq 0xe45f
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0x10c7f(%rip), %rax     # 0x1300c
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17ffe(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x41, 0xc(%rdi)
leaq 0x1372f(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x17d80(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x23f1
movq %r14, %rdi
callq 0xe4be
leaq 0x124ed(%rip), %rdi     # 0x148d4
movq %rax, %rsi
xorl %eax, %eax
callq 0x20e0
movq 0x30(%rbx), %rdi
callq 0x10e46
movq %rax, %rdi
callq 0xb248
movq %rax, %rdi
callq 0x20a0
movq %rsp, %rdi
movl $0x46, 0xc(%rdi)
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: label_msg
BEH_DECL(label_msg)
{
	CONS* state = MINE;
	CONS* label = map_get(state, ATOM("label"));
	CONS* ctx = map_get(state, ATOM("ctx"));
	CONS* cont = map_get(state, cont_symbol);

	DBUG_ENTER("label_msg");
	assert(!nilp(label));
	SEND(cont, map_put(ctx, label, WHAT));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r12
leaq 0x10bcc(%rip), %rdi     # 0x13016
callq 0xe45f
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0x10bb6(%rip), %rdi     # 0x1301c
callq 0xe45f
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x17cce(%rip), %rsi     # 0x1a150
movq %r12, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0x10bbb(%rip), %rax     # 0x13051
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17ef5(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x54, 0xc(%rdi)
leaq 0x13626(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x17c77(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
cmpq 0x17ae3(%rip), %r14     # 0x19fc0
je 0x251f
movq 0x30(%rbx), %rdi
callq 0x10e46
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x57, 0xc(%rdi)
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10afa(%rip), %rdi     # 0x13020
leaq 0x10b00(%rip), %rsi     # 0x1302d
leaq 0x10b02(%rip), %rcx     # 0x13036
pushq $0x55
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: unlabel_msg
BEH_DECL(unlabel_msg)
{
	CONS* state = MINE;
	CONS* label = map_get(state, ATOM("label"));
	CONS* cont = map_get(state, cont_symbol);
	CONS* value = map_get(WHAT, label);

	DBUG_ENTER("unlabel_msg");
	assert(!nilp(label));
	SEND(cont, value);
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r15
leaq 0x10ab1(%rip), %rdi     # 0x13016
callq 0xe45f
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x17bcf(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10e46
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0x10aa1(%rip), %rax     # 0x1304f
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x17ddd(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x65, 0xc(%rdi)
leaq 0x1350e(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x17b5f(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
cmpq 0x179cb(%rip), %r14     # 0x19fc0
je 0x2620
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x68, 0xc(%rdi)
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x109f9(%rip), %rdi     # 0x13020
leaq 0x109ff(%rip), %rsi     # 0x1302d
leaq 0x10a26(%rip), %rcx     # 0x1305b
pushq $0x66
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: apply_expr
BEH_DECL(apply_expr)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* form = map_get(state, form_symbol);
	CONS* cont = map_get(state, cont_symbol);
	CONS* env = map_get(state, env_symbol);
	
	DBUG_ENTER("apply_expr");
	if (actorp(expr)) {
		msg = NIL;
		msg = map_put(msg, env_symbol, env);
		msg = map_put(msg, cont_symbol, cont);
		msg = map_put(msg, expr_symbol, form);
		SEND(expr, msg);
	} else {	/* error */
		/* FIXME: consider the meaning of non-actor applications, such as numbers */
		SEND(an_error, ATOM("apply: actor required"));
		SEND(cont, map_put(NIL, expr_symbol, undefined_symbol));
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq 0x17afb(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r13
movq 0x17adb(%rip), %rsi     # 0x1a160
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x17ab7(%rip), %rsi     # 0x1a150
movq %r13, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x17abb(%rip), %rsi     # 0x1a168
movq %r13, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r13
leaq 0x109b5(%rip), %rax     # 0x13076
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17cc8(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x78, 0xc(%rdi)
leaq 0x133f9(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x17a4a(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movl %r14d, %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0x2750
movq 0x17a53(%rip), %rsi     # 0x1a168
leaq 0x17bec(%rip), %rdi     # 0x1a308
movq %r13, %rdx
callq 0x11339
movq 0x17a25(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r15, %rdx
callq 0x11339
movq 0x17a1b(%rip), %rsi     # 0x1a158
movq %rax, %rdi
movq %r12, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x2791
movq 0x17a19(%rip), %r14     # 0x1a170
leaq 0x10923(%rip), %rdi     # 0x13081
callq 0xe45f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x179e0(%rip), %rsi     # 0x1a158
movq 0x179f9(%rip), %rdx     # 0x1a178
leaq 0x17b82(%rip), %rdi     # 0x1a308
callq 0x11339
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x84, 0xc(%rdi)
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: apply_reduce
BEH_DECL(apply_reduce)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
	CONS* env = map_get(state, env_symbol);
	
	DBUG_ENTER("apply_reduce");
	DBUG_PRINT("", ("expr=%s", cons_to_str(expr)));
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, cont);
	msg = map_put(msg, expr_symbol, expr);
	SEND(a_reduce, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq 0x174ba(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq %rax, %r12
movq 0x1748a(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x1748e(%rip), %rsi     # 0x1a168
movq %r12, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0x1044d(%rip), %rax     # 0x1313b
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1769d(%rip), %rbp     # 0x1a398
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xd8, 0xc(%rdi)
leaq 0x12dcd(%rip), %r13     # 0x15ae4
movq %r13, 0x10(%rdi)
leaq 0x1741e(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
leaq 0x17c0a(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x2d7b
movq (%rbp), %rax
movq 0x50(%rax), %rax
movq %r13, 0x10(%rax)
movq %r13, %rdi
callq 0x12334
testl %eax, %eax
je 0x2d7b
movq (%rbp), %rax
movq 0x50(%rax), %rax
movl $0xd9, 0xc(%rax)
movq %r14, %rdi
callq 0xb248
leaq 0x10824(%rip), %rdi     # 0x13595
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x173e6(%rip), %rsi     # 0x1a168
leaq 0x1757f(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq 0x173b8(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r15, %rdx
callq 0x11339
movq 0x173ae(%rip), %rsi     # 0x1a158
movq %rax, %rdi
movq %r14, %rdx
callq 0x11339
movq 0x173d4(%rip), %rsi     # 0x1a190
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0xdf, 0xc(%rdi)
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_reduce
BEH_DECL(reduce_reduce)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);

	DBUG_ENTER("reduce_reduce");
	if (consp(expr)) {
		CONS* state;
		CONS* actor;

		/* evaluate first argument and send to apply actor */
		state = NIL;
		state = map_put(state, env_symbol, env);
		state = map_put(state, cont_symbol, cont);
		actor = ACTOR(apply_reduce, state);
		msg = NIL;
		msg = map_put(msg, env_symbol, env);
		msg = map_put(msg, cont_symbol, actor);
		msg = map_put(msg, expr_symbol, car(expr));
		SEND(a_reduce, msg);
	} else {	/* error */
		SEND(an_error, ATOM("reduce: illegal argument"));
		msg = NIL;
		msg = map_put(msg, expr_symbol, undefined_symbol);
		SEND(cont, msg);
	}
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq %rax, %r12
movq 0x17350(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x17334(%rip), %rsi     # 0x1a150
movq %r12, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x17338(%rip), %rsi     # 0x1a168
movq %r12, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
leaq 0x10304(%rip), %rax     # 0x13148
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x17545(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0xf0, 0xc(%rdi)
leaq 0x12c76(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x172c7(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
testq %r14, %r14
sete %al
testb $0x3, %r14b
setne %cl
orb %al, %cl
je 0x2edd
movq 0x172d2(%rip), %r14     # 0x1a170
leaq 0x102b1(%rip), %rdi     # 0x13156
callq 0xe45f
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x17299(%rip), %rsi     # 0x1a158
movq 0x172b2(%rip), %rdx     # 0x1a178
leaq 0x1743b(%rip), %rdi     # 0x1a308
callq 0x11339
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x2f6b
movq 0x17284(%rip), %rsi     # 0x1a168
leaq 0x1741d(%rip), %r13     # 0x1a308
movq %r13, %rdi
movq %r12, %rdx
callq 0x11339
movq 0x17253(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r15, %rdx
callq 0x11339
leaq -0x292(%rip), %rsi      # 0x2c7d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9ef7
movq %rax, %r15
movq 0x17244(%rip), %rsi     # 0x1a168
movq %r13, %rdi
movq %r12, %rdx
callq 0x11339
movq 0x1721a(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r15, %rdx
callq 0x11339
movq %rax, %r15
movq 0x1720d(%rip), %r12     # 0x1a158
movq %r14, %rdi
callq 0x10d3b
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x11339
movq 0x17228(%rip), %rsi     # 0x1a190
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x105, 0xc(%rdi)       # imm = 0x105
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_literal
BEH_DECL(reduce_literal)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
/*	CONS* env = map_get(msg, env_symbol); */
	
	DBUG_ENTER("reduce_literal");
	expr = car(expr);
	DBUG_PRINT("", ("expr=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq %rax, %r14
movq 0x171a3(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x17187(%rip), %rsi     # 0x1a150
movq %r14, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0x10192(%rip), %rax     # 0x1316f
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x173ac(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x113, 0xc(%rdi)       # imm = 0x113
leaq 0x12adc(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x1712d(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movq %r15, %rdi
callq 0x10d3b
movq %rax, %r15
leaq 0x1790e(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3077
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3077
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x115, 0xc(%rax)       # imm = 0x115
movq %r15, %rdi
callq 0xb248
leaq 0x10528(%rip), %rdi     # 0x13595
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x170da(%rip), %rsi     # 0x1a158
leaq 0x17283(%rip), %rdi     # 0x1a308
movq %r15, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x117, 0xc(%rdi)       # imm = 0x117
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: reduce_and_apply
BEH_DECL(reduce_and_apply)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* cont = map_get(msg, cont_symbol);
	CONS* env = map_get(msg, env_symbol);
	CONS* state = MINE;
	CONS* beh = map_get(state, beh_symbol);
	CONS* apply;

	DBUG_ENTER("reduce_and_apply");
	assert(funcp(beh));
	state = NIL;
	state = map_put(state, env_symbol, env);
	state = map_put(state, cont_symbol, cont);
	apply = ACTOR(MK_BEH(beh), state);
	msg = NIL;
	msg = map_put(msg, env_symbol, env);
	msg = map_put(msg, cont_symbol, apply);
	msg = map_put(msg, expr_symbol, expr);
	SEND(a_reduce_args, msg);
	DBUG_RETURN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq %rax, %r15
movq 0x1707a(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x1705e(%rip), %rsi     # 0x1a150
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x17062(%rip), %rsi     # 0x1a168
movq %r15, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x1706d(%rip), %rsi     # 0x1a198
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r13
leaq 0x1003f(%rip), %rax     # 0x1317e
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1724c(%rip), %rax     # 0x1a398
movq (%rax), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x129, 0xc(%rdi)       # imm = 0x129
leaq 0x1297d(%rip), %rcx     # 0x15ae4
movq %rcx, 0x10(%rdi)
leaq 0x16fce(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
movl %r13d, %eax
notl %eax
testb $0x3, %al
jne 0x3232
movq 0x16fd5(%rip), %rsi     # 0x1a168
leaq 0x1716e(%rip), %rbp     # 0x1a308
movq %rbp, %rdi
movq %r15, %rdx
callq 0x11339
movq 0x16fa4(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r12, %rdx
callq 0x11339
sarq $0x2, %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x9ef7
movq %rax, %r12
movq 0x16f95(%rip), %rsi     # 0x1a168
movq %rbp, %rdi
movq %r15, %rdx
callq 0x11339
movq 0x16f6b(%rip), %rsi     # 0x1a150
movq %rax, %rdi
movq %r12, %rdx
callq 0x11339
movq 0x16f61(%rip), %rsi     # 0x1a158
movq %rax, %rdi
movq %r14, %rdx
callq 0x11339
movq 0x16f97(%rip), %rsi     # 0x1a1a0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x9fd4
movq %rsp, %rdi
movl $0x134, 0xc(%rdi)       # imm = 0x134
callq 0x12d32
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xff56(%rip), %rdi      # 0x1318f
leaq 0xfded(%rip), %rsi      # 0x1302d
leaq 0xff53(%rip), %rcx      # 0x1319a
movl $0x12a, %edx            # imm = 0x12A
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: eval_list
BEH_DECL(eval_list)	/* FIXME:  this is a NO-OP, we should probably just use reduce_seq() directly */
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_list");
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq 0x16ee7(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x16eba(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r15
leaq 0xff10(%rip), %rax      # 0x131ba
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x170df(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x143, 0xc(%rdi)       # imm = 0x143
leaq 0x1280f(%rip), %r12     # 0x15ae4
movq %r12, 0x10(%rdi)
leaq 0x16e60(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
leaq 0x1764c(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x3339
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r12, 0x10(%rax)
movq %r12, %rdi
callq 0x12334
testl %eax, %eax
je 0x3339
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x144, 0xc(%rax)       # imm = 0x144
movq %r14, %rdi
callq 0xb248
leaq 0xfe95(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16e18(%rip), %rsi     # 0x1a158
leaq 0x16fc1(%rip), %rdi     # 0x1a308
movq %r14, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x146, 0xc(%rdi)       # imm = 0x146
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dalnefre[P]kernel_abe/reduce.c
// Function: eval_first
BEH_DECL(eval_first)
{
	CONS* msg = WHAT;
	CONS* expr = map_get(msg, expr_symbol);
	CONS* state = MINE;
	CONS* cont = map_get(state, cont_symbol);
/*	CONS* env = map_get(state, env_symbol); */
	
	DBUG_ENTER("eval_first");
	if (consp(expr) && consp(car(expr))) {
		CONS* p = car(expr);

		if (nilp(p)) {
			expr = NIL;
		} else {
			expr = car(p);
		}
	} else {	/* error */
		SEND(an_error, ATOM("first: list required"));
		expr = undefined_symbol;
	}
	DBUG_PRINT("", ("value=%s", cons_to_str(expr)));
	SEND(cont, map_put(NIL, expr_symbol, expr));
	DBUG_RETURN;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x10e46
movq 0x16dbc(%rip), %rsi     # 0x1a158
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r12
movq 0x30(%rbx), %rdi
callq 0x10d3b
movq %rax, %rdi
callq 0x929b
movq 0x16d8f(%rip), %rsi     # 0x1a150
movq %rax, %rdi
xorl %edx, %edx
callq 0x112c7
movq %rax, %r14
leaq 0xfdf8(%rip), %rax      # 0x131cd
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x16fb4(%rip), %r13     # 0x1a398
movq (%r13), %rax
movq 0x50(%rax), %rax
movl 0x8(%rax), %ecx
movl %ecx, 0x8(%rdi)
movl $0x158, 0xc(%rdi)       # imm = 0x158
leaq 0x126e4(%rip), %r15     # 0x15ae4
movq %r15, 0x10(%rdi)
leaq 0x16d35(%rip), %rcx     # 0x1a140
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
callq 0x12bb9
testq %r12, %r12
sete %al
testb $0x3, %r12b
setne %cl
orb %al, %cl
jne 0x3446
movq %r12, %rdi
callq 0x10d3b
testq %rax, %rax
je 0x3446
movq %r12, %rdi
callq 0x10d3b
testb $0x3, %al
je 0x34fd
movq 0x16d23(%rip), %r12     # 0x1a170
leaq 0xfd84(%rip), %rdi      # 0x131d8
callq 0xe45f
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9fd4
movq 0x16d0a(%rip), %r12     # 0x1a178
leaq 0x174cb(%rip), %rax     # 0x1a940
cmpl $0x0, (%rax)
je 0x34ba
movq (%r13), %rax
movq 0x50(%rax), %rax
movq %r15, 0x10(%rax)
movq %r15, %rdi
callq 0x12334
testl %eax, %eax
je 0x34ba
movq (%r13), %rax
movq 0x50(%rax), %rax
movl $0x165, 0xc(%rax)       # imm = 0x165
movq %r12, %rdi
callq 0xb248
leaq 0xfd14(%rip), %rdi      # 0x131c4
movq %rax, %rsi
xorl %eax, %eax
callq 0x12c30
movq 0x16c97(%rip), %rsi     # 0x1a158
leaq 0x16e40(%rip), %rdi     # 0x1a308
movq %r12, %rdx
callq 0x11339
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9fd4
leaq 0x8(%rsp), %rdi
movl $0x167, 0xc(%rdi)       # imm = 0x167
callq 0x12d32
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x10d3b
leaq 0x16dfc(%rip), %r12     # 0x1a308
cmpq %r12, %rax
je 0x346e
movq %rax, %rdi
callq 0x10d3b
movq %rax, %r12
jmp 0x346e