LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_definition_parameter
Definition* ast_definition_parameter(Line line, Pass pass, Id* identifiers, Type* type) {

    Definition* definition = MALLOC(definition, Definition);

    definition->line = line;
    definition->tag = DEFINITION_PARAMETER;
    definition->next = NULL;
    definition->parameter.pass = pass;
    definition->parameter.identifiers = identifiers;
    definition->parameter.type = type;

    return definition;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x30, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd36b
leaq 0x14d3a(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x9, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_expression_binary
Expression* ast_expression_binary(Line line, Operator operator, Expression* left_expression, Expression* right_expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_BINARY;
    expression_->next = NULL;
    expression_->binary.operator = operator;
    expression_->binary.left_expression = left_expression;
    expression_->binary.right_expression = right_expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd3fb
leaq 0x14caa(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_expression_unary
Expression* ast_expression_unary(Line line, Operator operator, Expression* expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_UNARY;
    expression_->next = NULL;
    expression_->unary.operator = operator;
    expression_->unary.expression = expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd487
leaq 0x14c1e(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_expression_variable
Expression* ast_expression_variable(Line line, Variable* variable) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_VARIABLE;
    expression_->next = NULL;
    expression_->variable.variable = variable;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd504
leaq 0x14ba1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%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/neosploit[P]compiler/ast.c
// Function: ast_expression_function_call
Expression* ast_expression_function_call(Line line, Id* id, Expression* expressions) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_FUNCTION_CALL;
    expression_->next = NULL;
    expression_->function_call.id = id;
    expression_->function_call.expressions = expressions;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd578
leaq 0x14b2d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_expression_length
Expression* ast_expression_length(Line line, Expression* expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_LENGTH;
    expression_->next = NULL;
    expression_->length.expression = expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd5f4
leaq 0x14ab1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%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/neosploit[P]compiler/ast.c
// Function: ast_expression_enclosed
Expression* ast_expression_enclosed(Line line, Expression* expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_ENCLOSED;
    expression_->next = NULL;
    expression_->enclosed.expression = expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd744
leaq 0x14961(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x7, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%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/neosploit[P]compiler/ast.c
// Function: ast_expression_setlist
Expression* ast_expression_setlist(Line line, Expression* expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_SETLIST;
    expression_->next = NULL;
    expression_->setlist.expression = expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd7b4
leaq 0x148f1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x8, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%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/neosploit[P]compiler/ast.c
// Function: ast_expression_limits
Expression* ast_expression_limits(Line line, Constant* lower_limit, Constant* upper_limit) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_LIMITS;
    expression_->next = NULL;
    expression_->limits.lower_limit = lower_limit;
    expression_->limits.upper_limit = upper_limit;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd828
leaq 0x1487d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x9, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_expression_iter_space
Expression* ast_expression_iter_space(Line line, IterSpace iter_space, Expression* initial_expression, Expression* final_expression) {

    Expression* expression_ = MALLOC(expression_, Expression);

    expression_->line = line;
    expression_->tag = EXPRESSION_ITER_SPACE;
    expression_->next = NULL;
    expression_->iter_space.iter_space = iter_space;
    expression_->iter_space.initial_expression = initial_expression;
    expression_->iter_space.final_expression = final_expression;

    return expression_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd91b
leaq 0x1478a(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0xb, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_variable_id
Variable* ast_variable_id(Line line, Id* id) {

    Variable* variable_ = MALLOC(variable_, Variable);

    variable_->line = line;
    variable_->tag = VARIABLE_ID;
    variable_->next = NULL;
    variable_->id.id = id;

    return variable_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd9a4
leaq 0x14701(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%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/neosploit[P]compiler/ast.c
// Function: ast_constant_integer
Constant* ast_constant_integer(Line line, Operator operator, int integer) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_INTEGER;
    constant->integer.operator = operator;
    constant->integer.integer = integer;

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdb96
leaq 0x1450f(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_constant_real
Constant* ast_constant_real(Line line, float real) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_REAL;
    constant->real = real;

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x10(%rbp)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdc05
leaq 0x144a0(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movss -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_constant_boolean
Constant* ast_constant_boolean(Line line, const char* boolean) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_BOOLEAN;
    constant->boolean = (!strcmp(boolean, "true")) ? true : false;

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdc74
leaq 0x14431(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x10(%rbp), %rdi
leaq 0x14414(%rip), %rsi     # 0x220a7
callq 0x7140
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_constant_character
Constant* ast_constant_character(Line line, char character) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_CHARACTER;
    constant->character = character;

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movl %edi, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x10(%rbp)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xdd06
leaq 0x1439f(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x3, 0x4(%rax)
movb -0x5(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_constant_string
Constant* ast_constant_string(Line line, const char* string) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_STRING;
    constant->string = strdup(string);

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdd64
leaq 0x14341(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x7260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_constant_id
Constant* ast_constant_id(Line line, Operator operator, Id* id) {

    Constant* constant = MALLOC(constant, Constant);

    constant->line = line;
    constant->tag = CONSTANT_ID;
    constant->id.operator = operator;
    constant->id.id = id;

    return constant;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xddd7
leaq 0x142ce(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x5, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_array
Type* ast_type_array(Line line, Expression* dims, Type* type) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_ARRAY;
    type_->array.dims = dims;
    type_->array.type = type;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xde48
leaq 0x1425d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_set
Type* ast_type_set(Line line, Type* type) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_SET;
    type_->set.type = type;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdeb4
leaq 0x141f1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_list
Type* ast_type_list(Line line, Type* type) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_LIST;
    type_->list.type = type;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdf14
leaq 0x14191(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_record
Type* ast_type_record(Line line, Definition* fields) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_RECORD;
    type_->record.fields = fields;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdf74
leaq 0x14131(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_enumeration
Type* ast_type_enumeration(Line line, Id* identifiers) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_ENUMERATION;
    type_->enumeration.identifiers = identifiers;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xdfd4
leaq 0x140d1(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x5, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_subrange
Type* ast_type_subrange(Line line, Constant* lower_limit, Constant* upper_limit) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_SUBRANGE;
    type_->subrange.lower_limit = lower_limit;
    type_->subrange.upper_limit = upper_limit;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe038
leaq 0x1406d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x6, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_type_id
Type* ast_type_id(Line line, Id* id) {

    Type* type_ = MALLOC(type_, Type);

    type_->line = line;
    type_->tag = TYPE_ID;
    type_->id.id = id;

    return type_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x7298
movq %rax, -0x18(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe234
leaq 0x13e71(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0xc, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast.c
// Function: ast_statement_assignment
Statement* ast_statement_assignment(Line line, Variable* variable, Expression* expression) {

    Statement* statement_ = MALLOC(statement_, Statement);

    statement_->line = line;
    statement_->tag = STATEMENT_ASSIGNMENT;
    statement_->next = NULL;
    statement_->assignment.variable = variable;
    statement_->assignment.expression = expression;

    return statement_;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x28, %edi
callq 0x7298
movq %rax, -0x20(%rbp)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe298
leaq 0x13e0d(%rip), %rdi     # 0x220a0
callq 0xcb00
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_print.c
// Function: ast_print_state_initialize
AstPrintState ast_print_state_initialize(AST* ast) {

    AstPrintState state;
    struct stat st;

    strcpy(state.filename, AST_OUTPUT_DIR_NAME);
    strcat(state.filename, "program.");
    strcat(state.filename, ast->header->program.id->identifier);
    strcat(state.filename, ".txt");

    state.indent = 0;

    if (stat(AST_OUTPUT_DIR_NAME, &st) < 0) {
        if (mkdir(AST_OUTPUT_DIR_NAME, 0600) < 0) {
            internal_error("mkdir");
        }
    }

    if (!(state.fp = fopen(state.filename, "w"))) {
        internal_error("fopen");
    }

    return state;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x13b40(%rip), %rsi     # 0x221c7
callq 0x7050
movq -0xa0(%rbp), %rdi
leaq 0x13b39(%rip), %rsi     # 0x221d3
callq 0x7240
movq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x7240
movq -0xa0(%rbp), %rdi
leaq 0x13b15(%rip), %rsi     # 0x221dc
callq 0x7240
movq -0xa0(%rbp), %rdi
movl $0x0, 0x40(%rdi)
leaq 0x13ae6(%rip), %rdi     # 0x221c7
leaq -0x98(%rbp), %rsi
callq 0x7190
cmpl $0x0, %eax
jge 0xe716
leaq 0x13ace(%rip), %rdi     # 0x221c7
movl $0x180, %esi            # imm = 0x180
callq 0x7060
cmpl $0x0, %eax
jge 0xe714
leaq 0x13ad2(%rip), %rdi     # 0x221e1
callq 0xcb00
jmp 0xe716
movq -0xa0(%rbp), %rdi
leaq 0x13786(%rip), %rsi     # 0x21eaa
callq 0x7210
movq -0xa0(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0xe746
leaq 0x13aa6(%rip), %rdi     # 0x221e7
callq 0xcb00
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_print.c
// Function: ast_definition_print_state_initialize
AstPrintState ast_definition_print_state_initialize(Definition* definition) {

    AstPrintState state;
    struct stat st;

    strcpy(state.filename, AST_OUTPUT_DIR_NAME);

    if (definition->subprogram.sub_header->tag == DEFINITION_FUNCTION) {
        strcat(state.filename, "function.");
        strcat(state.filename, definition->subprogram.sub_header->function.id->identifier);
    } else {
        strcat(state.filename, "procedure.");
        strcat(state.filename, definition->subprogram.sub_header->procedure.id->identifier);
    }

    strcat(state.filename, ".txt");

    state.indent = 0;

    if (stat(AST_OUTPUT_DIR_NAME, &st) < 0) {
        if (mkdir(AST_OUTPUT_DIR_NAME, 0600) < 0) {
            internal_error("mkdir");
        }
    }

    if (!(state.fp = fopen(state.filename, "w"))) {
        internal_error("fopen");
    }

    return state;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x13a40(%rip), %rsi     # 0x221c7
callq 0x7050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, 0x4(%rax)
jne 0xe7ca
movq -0xa8(%rbp), %rdi
leaq 0x13a45(%rip), %rsi     # 0x221ed
callq 0x7240
movq -0xa8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x7240
jmp 0xe7f8
movq -0xa8(%rbp), %rdi
leaq 0x13a1f(%rip), %rsi     # 0x221f7
callq 0x7240
movq -0xa8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x7240
movq -0xa8(%rbp), %rdi
leaq 0x139d6(%rip), %rsi     # 0x221dc
callq 0x7240
movq -0xa8(%rbp), %rax
movl $0x0, 0x40(%rax)
leaq 0x139a7(%rip), %rdi     # 0x221c7
leaq -0x98(%rbp), %rsi
callq 0x7190
cmpl $0x0, %eax
jge 0xe855
leaq 0x1398f(%rip), %rdi     # 0x221c7
movl $0x180, %esi            # imm = 0x180
callq 0x7060
cmpl $0x0, %eax
jge 0xe853
leaq 0x13993(%rip), %rdi     # 0x221e1
callq 0xcb00
jmp 0xe855
movq -0xa8(%rbp), %rdi
leaq 0x13647(%rip), %rsi     # 0x21eaa
callq 0x7210
movq -0xa8(%rbp), %rcx
movq %rax, 0x48(%rcx)
cmpq $0x0, %rax
jne 0xe885
leaq 0x13967(%rip), %rdi     # 0x221e7
callq 0xcb00
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_print.c
// Function: ast_print
void ast_print(AstPrintState* state, AST* ast) {

    ast_definition_print(state, ast->header);
    ast_declaration_print(state, ast->declarations);
    if (ast->subprograms) ast_definition_print(state, ast->subprograms);
    if (ast->comp_statement) ast_statement_print(state, ast->comp_statement);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xe910
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xed20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe8ed
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xe910
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe909
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xed90
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_print.c
// Function: ast_constant_print
void ast_constant_print(AstPrintState* state, Constant* constant) {

    switch (constant->tag) {
        case CONSTANT_INTEGER:
            if (constant->integer.operator != UNDEFINED) fprintf(state->fp, " (OPERATOR: %s)", OperatorString[constant->integer.operator]);
            fprintf(state->fp, " (ICONST: %d)", constant->integer.integer);

            break;
        case CONSTANT_REAL:
            fprintf(state->fp, " (RCONST: %lf)", constant->real);

            break;
        case CONSTANT_BOOLEAN:
            fprintf(state->fp, " (BCONST: %s)", constant->boolean ? "true" : "false");

            break;
        case CONSTANT_CHARACTER:
            fprintf(state->fp, " (CCONST: %c)", constant->character);

            break;
        case CONSTANT_STRING:
            fprintf(state->fp, " (SCONST: %s)", constant->string);

            break;
        case CONSTANT_ID:
            if (constant->id.operator != UNDEFINED) fprintf(state->fp, " (OPERATOR: %s)", OperatorString[constant->id.operator]);
            ast_id_print(state, constant->id.id);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xfbc3
movq -0x18(%rbp), %rax
leaq 0x126e8(%rip), %rcx     # 0x22168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xfabd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x1a6c5(%rip), %rax     # 0x2a170
movq (%rax,%rcx,8), %rdx
leaq 0x12860(%rip), %rsi     # 0x22316
movb $0x0, %al
callq 0x7170
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x129a9(%rip), %rsi     # 0x2247c
movb $0x0, %al
callq 0x7170
jmp 0xfbc3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1298f(%rip), %rsi     # 0x2248a
movb $0x1, %al
callq 0x7170
jmp 0xfbc3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
leaq 0x1298a(%rip), %rdx     # 0x224a7
leaq 0x12583(%rip), %rax     # 0x220a7
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x12967(%rip), %rsi     # 0x22499
movb $0x0, %al
callq 0x7170
jmp 0xfbc3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8(%rax), %edx
leaq 0x12958(%rip), %rsi     # 0x224ad
movb $0x0, %al
callq 0x7170
jmp 0xfbc3
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x12946(%rip), %rsi     # 0x224bb
movb $0x0, %al
callq 0x7170
jmp 0xfbc3
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xfbb2
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x1a5d0(%rip), %rax     # 0x2a170
movq (%rax,%rcx,8), %rdx
leaq 0x1276b(%rip), %rsi     # 0x22316
movb $0x0, %al
callq 0x7170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0xf130
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_free.c
// Function: ast_free
void ast_free(AST* ast) {

    ast_definition_free(ast->header);
    ast_declaration_free(ast->declarations);
    if (ast->subprograms) ast_definition_free(ast->subprograms);
    if (ast->comp_statement) ast_statement_free(ast->comp_statement);

    free(ast);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xfc40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfe10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xfc0d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfc40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xfc25
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xfe80
movq -0x8(%rbp), %rdi
callq 0x7290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_free.c
// Function: ast_declaration_free
static void ast_declaration_free(Declaration* declaration) {

    if (declaration->constdefs) ast_definition_free(declaration->constdefs);
    if (declaration->typedefs) ast_definition_free(declaration->typedefs);
    if (declaration->vardefs) ast_definition_free(declaration->vardefs);

    free(declaration);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfe32
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xfc40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xfe4a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfc40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xfe62
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xfc40
movq -0x8(%rbp), %rdi
callq 0x7290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_free.c
// Function: ast_type_free
static void ast_type_free(Type* type) {

    switch (type->tag) {
        case TYPE_UNDEFINED:
            break;
        case TYPE_ARRAY:
            ast_expression_free(type->array.dims);
            ast_type_free(type->array.type);

            break;
        case TYPE_SET:
            ast_type_free(type->set.type);

            break;
        case TYPE_LIST:
            ast_type_free(type->list.type);

            break;
        case TYPE_RECORD:
            ast_definition_free(type->record.fields);

            break;
        case TYPE_ENUMERATION:
            ast_id_free(type->enumeration.identifiers);

            break;
        case TYPE_SUBRANGE:
            ast_constant_free(type->subrange.lower_limit);
            ast_constant_free(type->subrange.upper_limit);

            break;
        case TYPE_INTEGER:
            break;
        case TYPE_REAL:
            break;
        case TYPE_BOOLEAN:
            break;
        case TYPE_CHARACTER:
            break;
        case TYPE_STRING:
            break;
        case TYPE_ID:
            ast_id_free(type->id.id);
    }

    free(type);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xc, %rax
ja 0x10245
movq -0x10(%rbp), %rax
leaq 0x124f8(%rip), %rcx     # 0x226a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10020
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10180
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10180
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10180
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfc40
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffe0
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10320
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10320
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
jmp 0x10245
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xffe0
movq -0x8(%rbp), %rdi
callq 0x7290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_free.c
// Function: ast_variable_free
static void ast_variable_free(Variable* variable) {

    if (variable->next) ast_variable_free(variable->next);

    switch (variable->tag) {
        case VARIABLE_ID:
            ast_id_free(variable->id.id);

            break;
        case VARIABLE_COMPONENT:
            ast_variable_free(variable->component.variable);
            ast_id_free(variable->component.id);

            break;
        case VARIABLE_INDEX:
            ast_variable_free(variable->index.variable);
            ast_expression_free(variable->index.expressions);

            break;
        case VARIABLE_LISTFUNC:
            ast_id_free(variable->listfunc.id);
            ast_expression_free(variable->listfunc.expression);
    }

    free(variable);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10284
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10260
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x1030a
movq -0x10(%rbp), %rax
leaq 0x12438(%rip), %rcx     # 0x226d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xffe0
jmp 0x1030a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10260
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xffe0
jmp 0x1030a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10260
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10020
jmp 0x1030a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xffe0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10020
movq -0x8(%rbp), %rdi
callq 0x7290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/ast_free.c
// Function: ast_constant_free
static void ast_constant_free(Constant* constant) {

    switch (constant->tag) {
        case CONSTANT_INTEGER:
            break;
        case CONSTANT_REAL:
            break;
        case CONSTANT_BOOLEAN:
            break;
        case CONSTANT_CHARACTER:
            break;
        case CONSTANT_STRING:
            free(constant->string);

            break;
        case CONSTANT_ID:
            ast_id_free(constant->id.id);
    }

    free(constant);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x5, %rax
ja 0x10375
movq -0x10(%rbp), %rax
leaq 0x123a0(%rip), %rcx     # 0x226e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x10375
jmp 0x10375
jmp 0x10375
jmp 0x10375
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7290
jmp 0x10375
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xffe0
movq -0x8(%rbp), %rdi
callq 0x7290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8casecmp
int utf8casecmp(const void *src1, const void *src2)
{
    utf8_int32_t src1_cp, src2_cp, src1_orig_cp, src2_orig_cp;

    for (;;) {
        src1 = utf8codepoint(src1, &src1_cp);
        src2 = utf8codepoint(src2, &src2_cp);

        // Take a copy of src1 & src2
        src1_orig_cp = src1_cp;
        src2_orig_cp = src2_cp;

        // Lower the srcs if required
        src1_cp = utf8lwrcodepoint(src1_cp);
        src2_cp = utf8lwrcodepoint(src2_cp);

        // Check if the lowered codepoints match
        if ((0 == src1_orig_cp) && (0 == src2_orig_cp)) {
            return 0;
        } else if (src1_cp == src2_cp) {
            continue;
        }

        // If they don't match, then we return which of the original's are less
        if (src1_orig_cp < src2_orig_cp) {
            return -1;
        } else if (src1_orig_cp > src2_orig_cp) {
            return 1;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x10440
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10440
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x10580
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %edi
callq 0x10580
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl -0x24(%rbp), %eax
jne 0x103fb
xorl %eax, %eax
cmpl -0x28(%rbp), %eax
jne 0x103fb
movl $0x0, -0x4(%rbp)
jmp 0x10430
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x10405
jmp 0x103a0
jmp 0x10407
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x10418
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10430
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x10429
movl $0x1, -0x4(%rbp)
jmp 0x10430
jmp 0x1042b
jmp 0x103a0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8codepoint
void *utf8codepoint(const void *utf8_restrict str,
                    utf8_int32_t *utf8_restrict out_codepoint)
{
    const char *s = (const char *)str;

    if (0xf0 == (0xf8 & s[0])) {
        // 4 byte utf8 codepoint
        *out_codepoint = ((0x07 & s[0]) << 18) | ((0x3f & s[1]) << 12) |
                         ((0x3f & s[2]) << 6) | (0x3f & s[3]);
        s += 4;
    } else if (0xe0 == (0xf0 & s[0])) {
        // 3 byte utf8 codepoint
        *out_codepoint =
            ((0x0f & s[0]) << 12) | ((0x3f & s[1]) << 6) | (0x3f & s[2]);
        s += 3;
    } else if (0xc0 == (0xe0 & s[0])) {
        // 2 byte utf8 codepoint
        *out_codepoint = ((0x1f & s[0]) << 6) | (0x3f & s[1]);
        s += 2;
    } else {
        // 1 byte utf8 codepoint otherwise
        *out_codepoint = s[0];
        s += 1;
    }

    return (void *)s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0xf8, %ecx
movl $0xf0, %eax
cmpl %ecx, %eax
jne 0x104bb
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0x7, %ecx
shll $0x12, %ecx
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0x3f, %eax
shll $0xc, %eax
orl %eax, %ecx
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %eax, %ecx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %eax
andl $0x3f, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x10570
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0xf0, %ecx
movl $0xe0, %eax
cmpl %ecx, %eax
jne 0x1050f
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0xf, %ecx
shll $0xc, %ecx
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0x3f, %eax
shll $0x6, %eax
orl %eax, %ecx
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0x3f, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x1056e
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0xe0, %ecx
movl $0xc0, %eax
cmpl %ecx, %eax
jne 0x10553
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
andl $0x1f, %ecx
shll $0x6, %ecx
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0x3f, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x1056c
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1056e
jmp 0x10570
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neosploit[P]compiler/libfort/lib/fort.c
// Function: utf8cat
void *utf8cat(void *utf8_restrict dst, const void *utf8_restrict src)
{
    char *d = (char *)dst;
    const char *s = (const char *)src;

    // find the null terminating byte in dst
    while ('\0' != *d) {
        d++;
    }

    // overwriting the null terminating byte in dst, append src byte-by-byte
    while ('\0' != *s) {
        *d++ = *s++;
    }

    // write out a new null terminating byte into dst
    *d = '\0';

    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x10c17
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10bfc
jmp 0x10c19
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x10c4a
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x10c19
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)