LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::push_var_def(Var_Def)
void Type_Checker::push_var_def(Var_Def var_def)
{
    assert(scope);
    auto args_list = memory->alloc<Args_List>();
    args_list->var_def = var_def;
    args_list->next = scope->args_list;
    scope->args_list = args_list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x1b76
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movq (%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x5c62
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x689a(%rip), %rdi      # 0x8417
leaq 0x6899(%rip), %rsi      # 0x841d
leaq 0x68cc(%rip), %rcx      # 0x8457
pushq $0x26
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::cast_expression_to(Expression*, Type)
Expression *Type_Checker::cast_expression_to(Expression *expression, Type type)
{
    Expression *cast_expression = memory->alloc<Expression>();
    cast_expression->kind = Expression_Kind::Type_Cast;
    cast_expression->type = type;
    cast_expression->offset = expression->offset;
    cast_expression->type_cast.type = cast_expression->type;
    cast_expression->type_cast.expression = expression;
    return cast_expression;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq (%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x5ce2
movl $0x4, (%rax)
movl %ebx, 0x4(%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: is_expression_implicitly_convertible_to(Expression*, Type)
bool is_expression_implicitly_convertible_to(Expression *expression, Type target_type)
{
    assert(expression->type != Type::Unchecked && "Unchecked type in a checked context");
    assert(target_type != Type::Unchecked && "Unchecked type in a checked context");

    for (size_t i = 0; i < implicit_conversion_table_count; ++i) {
        const size_t SOURCE = 0;
        const size_t TARGET = 1;
        if (implicit_conversion_table[i][SOURCE] == expression->type &&
            implicit_conversion_table[i][TARGET] == target_type) {
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x1bff
testl %esi, %esi
je 0x1c18
xorl %ecx, %ecx
leaq 0x66b0(%rip), %rdx      # 0x8290
cmpq $0xb, %rcx
je 0x1bf6
cmpl %eax, (%rdx,%rcx,8)
jne 0x1bf1
cmpl %esi, 0x4(%rdx,%rcx,8)
je 0x1bf6
incq %rcx
jmp 0x1be0
cmpq $0xb, %rcx
setb %al
popq %rbp
retq
leaq 0x687a(%rip), %rdi      # 0x8480
leaq 0x6810(%rip), %rsi      # 0x841d
leaq 0x68b9(%rip), %rcx      # 0x84cd
pushq $0x55
jmp 0x1c2f
leaq 0x68ef(%rip), %rdi      # 0x850e
leaq 0x67f7(%rip), %rsi      # 0x841d
leaq 0x68a0(%rip), %rcx      # 0x84cd
pushq $0x56
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_local_var_def(Local_Var_Def*, Type)
void Type_Checker::check_types_of_local_var_def(Local_Var_Def *local_var_def, Type expected_type)
{
    local_var_def->value = try_implicitly_convert_expression_to(
        check_types_of_expression(local_var_def->value),
        local_var_def->def.type);

    const auto TYPE_OF_LOCAL_VAR_DEF = Type::U0;

    if (expected_type != TYPE_OF_LOCAL_VAR_DEF) {
        // TODO: use offset of the local_var_def itself instead of its value;
        reporter.fail(local_var_def->value->offset, "Expected statement of type `", expected_type, "`, but local variable definition has the type `", TYPE_OF_LOCAL_VAR_DEF, "`");
    }

    push_var_def(local_var_def->def);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r12
movq %r12, %rsi
callq 0x1d32
movl 0x10(%r15), %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1c36
movq %rax, 0x18(%r15)
cmpl $0x1, %r14d
jne 0x1d01
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1b34
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rbx
movq 0x8(%rax), %rsi
leaq 0x6985(%rip), %rax      # 0x8695
movq %rax, (%rsp)
leaq 0x686a(%rip), %rdx      # 0x8585
leaq 0x6880(%rip), %r8       # 0x85a2
pushq $0x1
popq %r9
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x5d62
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_while(While*, Type)
void Type_Checker::check_types_of_while(While *hwile, Type expected_type)
{
    hwile->condition = try_implicitly_convert_expression_to(
        check_types_of_expression(hwile->condition),
        Type::Bool);
    // TODO: use offset of the hwile body itself instead of its condition
    check_types_of_block(hwile->condition->offset, hwile->body, Type::U0);

    const auto TYPE_OF_WHILE = Type::U0;
    if (expected_type != TYPE_OF_WHILE) {
        // TODO: use offset of the hwile itself instead of its condition;
        reporter.fail(hwile->condition->offset, "Expected statement of type `", expected_type, "`, but while-loop construction has the type `", TYPE_OF_WHILE, "`");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
movq %r12, %rsi
callq 0x1d32
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1c36
movq %rax, (%r15)
movq 0x8(%rax), %rsi
movq 0x8(%r15), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x202a
cmpl $0x1, %ebx
jne 0x1ff8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
movq (%r15), %rax
movq 0x8(%rax), %rsi
leaq 0x668b(%rip), %rax      # 0x8695
movq %rax, (%rsp)
leaq 0x6570(%rip), %rdx      # 0x8585
leaq 0x65b6(%rip), %r8       # 0x85d2
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %ecx
callq 0x5d62
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_block(unsigned long, Block*, Type)
void Type_Checker::check_types_of_block(size_t offset, Block *block, Type expected_type)
{
    push_scope();

    if (!block) {
        const Type TYPE_OF_EMPTY_BLOCK = Type::U0;
        if (expected_type != TYPE_OF_EMPTY_BLOCK) {
            reporter.fail(offset, "Expected type `", expected_type, "` but empty block has type `", TYPE_OF_EMPTY_BLOCK, "`");
        }
    }

    while (block && block->next != nullptr) {
        check_types_of_statement(&block->statement, Type::U0);
        block = block->next;
    }

    if (block) {
        check_types_of_statement(&block->statement, expected_type);
    }

    pop_scope();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %esi, %esi
callq 0x1ad4
testq %r15, %r15
sete %al
cmpl $0x1, %ebx
setne %cl
testb %cl, %al
jne 0x20a0
pushq $0x1
popq %r12
testq %r15, %r15
je 0x208c
cmpq $0x0, 0x30(%r15)
je 0x207f
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2258
movq 0x30(%r15), %r15
jmp 0x205f
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x2258
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1b00
addq $0x8, %r14
leaq 0x65ea(%rip), %rax      # 0x8695
movq %rax, (%rsp)
leaq 0x66af(%rip), %rdx      # 0x8765
leaq 0x66b8(%rip), %r8       # 0x8775
pushq $0x1
popq %r9
movq %r14, %rdi
movq %r12, %rsi
movl %ebx, %ecx
callq 0x5d62
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_if(If*, Type)
void Type_Checker::check_types_of_if(If *iph, Type expected_type)
{
    iph->condition = try_implicitly_convert_expression_to(
        check_types_of_expression(iph->condition),
        Type::Bool);
    // TODO: use offsets of the `then` and `else` blocks themselves instead of the if condition
    check_types_of_block(iph->condition->offset, iph->then, expected_type);
    check_types_of_block(iph->condition->offset, iph->elze, expected_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %r12
movq %r12, %rsi
callq 0x1d32
pushq $0x5
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c36
movq %rax, (%r14)
movq 0x8(%rax), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %ecx
callq 0x202a
movq (%r14), %rax
movq 0x10(%r14), %rdx
movq 0x8(%rax), %rsi
movq %r15, %rdi
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x202a
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_assignment(Assignment*, Type)
void Type_Checker::check_types_of_assignment(Assignment *assignment, Type expected_type)
{
    // TODO: check_types_of_assignment should report errors on the assignment's offset, not its value one
    // TODO: assigment could be an expression that has the type of the variable it assigns
    size_t offset = assignment->value->offset;
    assignment->value = try_implicitly_convert_expression_to(
        check_types_of_expression(assignment->value),
        type_of_name(offset, assignment->var_name));

    const auto TYPE_OF_ASSIGNMENT = Type::U0;
    if (expected_type != TYPE_OF_ASSIGNMENT) {
        // TODO: use offset of the assignment itself instead of its value
        reporter.fail(assignment->value->offset, "Expected statement of type `", expected_type, "`, but assignment has the type `", TYPE_OF_ASSIGNMENT, "`");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %r12
movq 0x8(%r12), %r13
movq %r12, %rsi
callq 0x1d32
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1a40
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1c36
movq %rax, 0x10(%r15)
cmpl $0x1, %ebx
jne 0x218a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
movq 0x8(%rax), %rsi
leaq 0x64fc(%rip), %rax      # 0x8695
movq %rax, (%rsp)
leaq 0x63e1(%rip), %rdx      # 0x8585
leaq 0x6455(%rip), %r8       # 0x8600
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %ecx
callq 0x5d62
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_return(Return*, Type)
void Type_Checker::check_types_of_return(Return *reeturn, Type expected_type)
{
    assert(current_func_def && "Type checking return statement outside of a Func_Def context");
    reeturn->value = try_implicitly_convert_expression_to(
        check_types_of_expression(reeturn->value),
        current_func_def->return_type);

    const auto TYPE_OF_RETURN = Type::U0;
    if (expected_type != TYPE_OF_RETURN) {
        // TODO: use offset of the assignment itself instead of its value
        reporter.fail(reeturn->value->offset, "Expected statement of type `", expected_type, "`, but return has the type `", TYPE_OF_RETURN, "`");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x220a
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
movq %r12, %rsi
callq 0x1d32
movq 0x30(%r14), %rax
movl 0x18(%rax), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1c36
movq %rax, (%r15)
cmpl $0x1, %ebx
jne 0x2229
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64ab(%rip), %rdi      # 0x86bc
leaq 0x6205(%rip), %rsi      # 0x841d
leaq 0x64f0(%rip), %rcx      # 0x870f
movl $0xfd, %edx
callq 0x1090
addq $0x8, %r14
movq 0x8(%rax), %rsi
leaq 0x645d(%rip), %rax      # 0x8695
movq %rax, (%rsp)
leaq 0x6342(%rip), %rdx      # 0x8585
leaq 0x64fe(%rip), %r8       # 0x8748
pushq $0x1
popq %r9
movq %r14, %rdi
movl %ebx, %ecx
callq 0x5d62
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_statement(Statement*, Type)
void Type_Checker::check_types_of_statement(Statement *statement, Type expected_type)
{
    switch (statement->kind) {
    case Statement_Kind::Local_Var_Def:
        check_types_of_local_var_def(&statement->local_var_def, expected_type);
        break;
    case Statement_Kind::While:
        check_types_of_while(&statement->hwile, expected_type);
        break;
    case Statement_Kind::If:
        check_types_of_if(&statement->iph, expected_type);
        break;
    case Statement_Kind::Assignment:
        check_types_of_assignment(&statement->assignment, expected_type);
        break;
    case Statement_Kind::Expression:
        statement->expression = try_implicitly_convert_expression_to(
            check_types_of_expression(statement->expression),
            expected_type);
        break;
    case Statement_Kind::Return:
        check_types_of_return(&statement->reeturn, expected_type);
        break;
    }

    statement->type = expected_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl (%rsi), %eax
cmpq $0x5, %rax
ja 0x22f7
movq %rdi, %r15
leaq 0x5dde(%rip), %rcx      # 0x805c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x1c9e
jmp 0x22f7
movq 0x10(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d32
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1c36
movq %rax, 0x10(%r14)
jmp 0x22f7
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x20ce
jmp 0x22f7
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x212c
jmp 0x22f7
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x1fa0
jmp 0x22f7
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x21ba
movl %ebx, 0x4(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_func_def(Func_Def*)
void Type_Checker::check_types_of_func_def(Func_Def *func_def)
{
    assert(current_func_def == nullptr &&
           "Checking types of Func_Def in the contenxt of other Func_Def. This kinda stuff is not supported yet.");
    current_func_def = func_def;
    push_scope(func_def->args_list);
    // TODO: use offset of the body instead of func_def
    check_types_of_block(func_def->offset, func_def->body, func_def->return_type);
    current_func_def = nullptr;
    pop_scope();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x30(%rdi)
jne 0x234a
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x30(%rdi)
movq 0x10(%rsi), %rsi
callq 0x1ad4
movq 0x28(%r14), %rsi
movq 0x20(%r14), %rdx
movl 0x18(%r14), %ecx
movq %rbx, %rdi
callq 0x202a
andq $0x0, 0x30(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1b00
leaq 0x6441(%rip), %rdi      # 0x8792
leaq 0x60c5(%rip), %rsi      # 0x841d
leaq 0x64b9(%rip), %rcx      # 0x8818
movl $0x13f, %edx            # imm = 0x13F
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::check_types_of_module(Module*)
void Type_Checker::check_types_of_module(Module *module)
{
    auto top_level_def = module->top_level_defs;
    while (top_level_def) {
        check_types_of_func_def(&top_level_def->func_def);
        top_level_def = top_level_def->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2390
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2304
addq $0x30, %rbx
jmp 0x2377
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Top_Level_Def*)
void print1(FILE *stream, Top_Level_Def *top_level_def)
{
    print(stream, "(");
    while (top_level_def) {
        print(stream, top_level_def->func_def, " ");
        top_level_def = top_level_def->next;
    }
    print(stream, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5c77(%rip), %rsi      # 0x89ab
callq 0x16f9
leaq 0x5c63(%rip), %r15      # 0x89a3
testq %r14, %r14
je 0x2d72
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5f85
movq 0x30(%r14), %r14
jmp 0x2d40
leaq 0x56dc(%rip), %rsi      # 0x8455
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f9
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Statement)
void print1(FILE *stream, Statement statement)
{
    switch (statement.kind) {
    case Statement_Kind::If:
        print(stream, "(if ", *statement.iph.condition, " ", statement.iph.then, " ", statement.iph.elze, ")");
        break;
    case Statement_Kind::While:
        print(stream, "(while ", *statement.hwile.condition, " ", statement.hwile.body, ")");
        break;
    case Statement_Kind::Local_Var_Def:
        print(stream, "(local ", statement.local_var_def.def, " ", *statement.local_var_def.value, ")");
        break;
    case Statement_Kind::Assignment:
        print(stream, "(= ", statement.assignment.var_name, " ", *statement.assignment.value, ")");
        break;
    case Statement_Kind::Return:
        print(stream, "(return ", *statement.reeturn.value, ")");
        break;
    case Statement_Kind::Expression:
        print(stream, *statement.expression);
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %ecx
cmpq $0x5, %rcx
ja 0x3185
leaq 0x10(%rbp), %rax
leaq 0x50c9(%rip), %rdx      # 0x810c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x28(%rax), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups 0x10(%rax), %xmm0
movups %xmm0, (%rsp)
leaq 0x599d(%rip), %rsi      # 0x8a16
leaq 0x5923(%rip), %rdx      # 0x89a3
leaq 0x53ce(%rip), %rcx      # 0x8455
callq 0x61d6
jmp 0x3185
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2dc7
jmp 0x3185
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movq 0x20(%rax), %r9
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x5383(%rip), %rax      # 0x8455
movq %rax, 0x20(%rsp)
leaq 0x592b(%rip), %rsi      # 0x8a09
leaq 0x58be(%rip), %rdx      # 0x89a3
movq %rdx, %r8
callq 0x60e7
jmp 0x3185
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x5909(%rip), %rsi      # 0x8a1e
leaq 0x5887(%rip), %r8       # 0x89a3
leaq 0x5332(%rip), %r9       # 0x8455
callq 0x6257
jmp 0x3185
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x58c5(%rip), %rsi      # 0x8a0e
leaq 0x5853(%rip), %rdx      # 0x89a3
leaq 0x52fe(%rip), %r8       # 0x8455
callq 0x6170
jmp 0x3185
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x58a9(%rip), %rsi      # 0x8a22
leaq 0x52d5(%rip), %rdx      # 0x8455
callq 0x62c7
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Block*)
void print1(FILE *stream, Block *block)
{
    print(stream, "(");
    while (block) {
        print(stream, block->statement, " ");
        block = block->next;
    }
    print(stream, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5806(%rip), %rsi      # 0x89ab
callq 0x16f9
leaq 0x57f2(%rip), %r15      # 0x89a3
testq %r14, %r14
je 0x31eb
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3023
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16f9
movq 0x30(%r14), %r14
jmp 0x31b1
leaq 0x5263(%rip), %rsi      # 0x8455
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f9
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Args_List*)
void print1(FILE *stream, Args_List *args_list)
{
    print(stream, "(");
    while (args_list) {
        print(stream, args_list->var_def, " ");
        args_list = args_list->next;
    }
    print(stream, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5734(%rip), %rsi      # 0x89ab
callq 0x16f9
leaq 0x5720(%rip), %r15      # 0x89a3
testq %r14, %r14
je 0x32aa
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x636d
movq 0x18(%r14), %r14
jmp 0x3283
leaq 0x51a4(%rip), %rsi      # 0x8455
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f9
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_var_def()
Var_Def Parser::parse_var_def()
{
    Var_Def var_def = {};

    expect_token_type(Token_Type::Symbol);
    var_def.name = tokens.items->text;
    tokens.chop(1);

    var_def.type = parse_type_annotation();

    return var_def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x6470
movq 0x10(%rbx), %rax
andq $0x0, 0x10(%r14)
leaq 0x8(%rbx), %rdi
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
pushq $0x1
popq %rsi
callq 0x64f6
movq %rbx, %rdi
callq 0x334e
movl %eax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_type_annotation()
Type Parser::parse_type_annotation()
{
    expect_token_type(Token_Type::Colon);
    tokens.chop(1);

    expect_token_type(Token_Type::Symbol);
    auto type_name = tokens.items->text;

    if (type_name == "u32"_sv) {
        tokens.chop(1);
        return Type::U32;
    } else if (type_name == "u64"_sv) {
        tokens.chop(1);
        return Type::U64;
    } else if (type_name == "u8"_sv) {
        tokens.chop(1);
        return Type::U8;
    } else if (type_name == "bool"_sv) {
        tokens.chop(1);
        return Type::Bool;
    } else {
        reporter.fail(current_offset(), "Unknown type `", type_name, "`");
        return Type::Unchecked;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x4
popq %r15
movl %r15d, %esi
callq 0x6470
leaq 0x8(%r14), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x64f6
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6470
movq 0x10(%r14), %rax
movups 0x8(%rax), %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
leaq 0x5697(%rip), %rdx      # 0x8a31
pushq $0x3
popq %rsi
callq 0x5b90
testb %al, %al
je 0x33ac
pushq $0x3
popq %r15
jmp 0x33c3
leaq 0x5682(%rip), %rdx      # 0x8a35
leaq -0x30(%rbp), %rdi
pushq $0x3
popq %rsi
callq 0x5b90
testb %al, %al
je 0x33dc
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x64f6
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x564b(%rip), %rdx      # 0x8a2e
leaq -0x30(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x5b90
testb %al, %al
je 0x33f7
pushq $0x2
jmp 0x33a8
leaq 0x563b(%rip), %rdx      # 0x8a39
leaq -0x30(%rbp), %rdi
pushq $0x4
popq %rsi
callq 0x5b90
testb %al, %al
je 0x3412
pushq $0x5
jmp 0x33a8
leaq 0x18(%r14), %rbx
movq %r14, %rdi
callq 0x6528
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x561c(%rip), %rdx      # 0x8a49
leaq 0x5261(%rip), %r9       # 0x8695
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5bb6
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_args_list()
Args_List *Parser::parse_args_list()
{
    expect_token_type(Token_Type::Open_Paren);
    tokens.chop(1);

    Args_List *result = nullptr;
    Args_List *last_arg = nullptr;

    while (tokens.count > 0) {
        Args_List *arg = memory->alloc<Args_List>();
        arg->var_def = parse_var_def();

        if (last_arg == nullptr)  {
            result = arg;
        } else {
            last_arg->next = arg;
        }
        last_arg = arg;

        if (tokens.items->type != Token_Type::Comma) {
            expect_token_type(Token_Type::Closed_Paren);
            tokens.chop(1);
            return result;
        }

        tokens.chop(1);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x2
popq %rsi
callq 0x6470
leaq 0x8(%rbx), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x64f6
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq $0x0, (%r15)
je 0x34e5
movq %r12, -0x30(%rbp)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x5c62
movq %rax, %r13
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x3304
movq -0x38(%rbp), %rax
movq %rax, 0x10(%r13)
movups -0x48(%rbp), %xmm0
movups %xmm0, (%r13)
movq %r13, %r12
testq %r14, %r14
je 0x34b6
movq %r13, 0x18(%r14)
movq -0x30(%rbp), %r12
movq 0x10(%rbx), %rax
cmpl $0x5, (%rax)
jne 0x34cf
movq %r15, %rdi
pushq $0x1
popq %rsi
callq 0x64f6
movq %r13, %r14
jmp 0x3471
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6470
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x64f6
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_if()
If Parser::parse_if()
{
    If result = {};
    expect_token_type(Token_Type::If);
    tokens.chop(1);

    expect_token_type(Token_Type::Open_Paren);
    tokens.chop(1);

    result.condition = parse_expression();

    expect_token_type(Token_Type::Closed_Paren);
    tokens.chop(1);

    result.then = parse_block();

    if (tokens.count > 0 && tokens.items->type == Token_Type::Else) {
        tokens.chop(1);
        result.elze = parse_block();
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
pushq $0x16
popq %rsi
movq %r14, %rdi
callq 0x6470
leaq 0x8(%r14), %r15
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %r14, %rdi
callq 0x35a2
movq %rax, (%rbx)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %r14, %rdi
callq 0x35d4
movq %rax, 0x8(%rbx)
cmpq $0x0, 0x8(%r14)
je 0x3596
movq 0x10(%r14), %rax
cmpl $0x17, (%rax)
jne 0x3596
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x64f6
movq %r14, %rdi
callq 0x35d4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_block()
Block *Parser::parse_block()
{
    expect_token_type(Token_Type::Open_Curly);
    tokens.chop(1);

    Block *result = nullptr;
    Block *last_st = nullptr;

    while (tokens.count > 0 && tokens.items->type != Token_Type::Closed_Curly) {
        Block *st = memory->alloc<Block>();
        st->statement = parse_statement();

        if (last_st == nullptr)  {
            result = st;
        } else {
            last_st->next = st;
        }
        last_st = st;
    }

    expect_token_type(Token_Type::Closed_Curly);
    tokens.chop(1);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x6
popq %rsi
callq 0x6470
leaq 0x8(%rbx), %r14
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x64f6
xorl %r12d, %r12d
leaq -0x60(%rbp), %r13
movq %r12, -0x30(%rbp)
cmpq $0x0, (%r14)
je 0x3660
movq 0x10(%rbx), %rax
cmpl $0x7, (%rax)
je 0x3660
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6564
movq %rax, %r15
movq %r13, %rdi
movq %rbx, %rsi
callq 0x39bc
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x40(%rbp), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
testq %r12, %r12
je 0x365b
movq %r15, 0x30(%r12)
movq %r15, %r12
jmp 0x360a
movq %r15, %r12
jmp 0x3606
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x6470
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x64f6
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_while()
While Parser::parse_while()
{
    While result = {};

    expect_token_type(Token_Type::While);
    tokens.chop(1);

    expect_token_type(Token_Type::Open_Paren);
    tokens.chop(1);

    result.condition = parse_expression();

    expect_token_type(Token_Type::Closed_Paren);
    tokens.chop(1);

    result.body = parse_block();

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0xc
popq %rsi
callq 0x6470
leaq 0x8(%rbx), %r14
pushq $0x1
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x64f6
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6470
movq %r14, %rdi
movq %r15, %rsi
callq 0x64f6
movq %rbx, %rdi
callq 0x35a2
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6470
movq %r14, %rdi
movq %r15, %rsi
callq 0x64f6
movq %rbx, %rdi
callq 0x35d4
movq %rax, %rdx
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_dummy_statement()
Statement Parser::parse_dummy_statement()
{
    while (tokens.count > 0 && tokens.items->type != Token_Type::Semicolon) {
        tokens.chop(1);
    }

    expect_token_type(Token_Type::Semicolon);
    tokens.chop(1);

    return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
pushq $0x1
popq %r12
cmpq $0x0, (%r14)
je 0x3737
movq 0x10(%r15), %rax
cmpl $0x13, (%rax)
je 0x3737
movq %r14, %rdi
movq %r12, %rsi
callq 0x64f6
jmp 0x371b
pushq $0x13
popq %rsi
movq %r15, %rdi
callq 0x6470
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x64f6
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_assignment()
Assignment Parser::parse_assignment()
{
    Assignment assignment = {};

    expect_token_type(Token_Type::Symbol);
    assignment.var_name = tokens.items->text;
    tokens.chop(1);

    expect_token_type(Token_Type::Equals);
    tokens.chop(1);

    assignment.value = parse_expression();

    expect_token_type(Token_Type::Semicolon);
    tokens.chop(1);

    return assignment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6470
leaq 0x8(%r14), %r15
movq 0x10(%r14), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %r14, %rdi
callq 0x35a2
movq %rax, 0x10(%rbx)
pushq $0x13
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_add_assignment()
Assignment Parser::parse_add_assignment()
{
    Assignment assignment = {};

    expect_token_type(Token_Type::Symbol);
    assignment.var_name = tokens.items->text;
    tokens.chop(1);

    expect_token_type(Token_Type::Plus_Equals);
    tokens.chop(1);

    assignment.value = memory->alloc<Expression>();
    assignment.value->kind = Expression_Kind::Plus;
    assignment.value->binary_op.lhs = memory->alloc<Expression>();
    assignment.value->binary_op.lhs->kind = Expression_Kind::Variable;
    assignment.value->binary_op.lhs->variable.name = assignment.var_name;
    assignment.value->binary_op.rhs = parse_expression();

    expect_token_type(Token_Type::Semicolon);
    tokens.chop(1);

    return assignment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6470
leaq 0x8(%r14), %r15
movq 0x10(%r14), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
pushq $0x11
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq (%r14), %rdi
movq %r12, %rsi
callq 0x5ce2
movq %rax, %r13
movq %rax, 0x10(%rbx)
movl $0x2, (%rax)
movq (%r14), %rdi
movq %r12, %rsi
callq 0x5ce2
movq %rax, 0x10(%r13)
movl $0x1, (%rax)
movq 0x10(%r13), %rax
movups (%rbx), %xmm0
movups %xmm0, 0x10(%rax)
movq %r14, %rdi
callq 0x35a2
movq %rax, 0x18(%r13)
pushq $0x13
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_return()
Return Parser::parse_return()
{
    expect_token_type(Token_Type::Return);
    tokens.chop(1);

    Return reeturn = {};
    reeturn.value = parse_expression();

    expect_token_type(Token_Type::Semicolon);
    tokens.chop(1);

    return reeturn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x19
popq %rsi
callq 0x6470
leaq 0x8(%rbx), %r14
pushq $0x1
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x64f6
movq %rbx, %rdi
callq 0x35a2
movq %rax, %r12
pushq $0x13
popq %rsi
movq %rbx, %rdi
callq 0x6470
movq %r14, %rdi
movq %r15, %rsi
callq 0x64f6
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_local_var_def()
Local_Var_Def Parser::parse_local_var_def()
{
    Local_Var_Def local_var_def = {};

    expect_token_type(Token_Type::Local);
    tokens.chop(1);

    local_var_def.def = parse_var_def();

    expect_token_type(Token_Type::Equals);
    tokens.chop(1);

    local_var_def.value = parse_expression();

    expect_token_type(Token_Type::Semicolon);
    tokens.chop(1);

    return local_var_def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x6470
leaq 0x8(%r14), %r15
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3304
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %r14, %rdi
callq 0x35a2
movq %rax, 0x18(%rbx)
pushq $0x13
popq %rsi
movq %r14, %rdi
callq 0x6470
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_func_def()
Func_Def Parser::parse_func_def()
{
    Func_Def func_def = {};

    expect_token_type(Token_Type::Func);
    tokens.chop(1);

    expect_token_type(Token_Type::Symbol);
    func_def.name = tokens.items->text;
    func_def.offset = current_offset();
    tokens.chop(1);

    func_def.args_list = parse_args_list();
    func_def.return_type = parse_type_annotation();
    func_def.body = parse_block();

    return func_def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x6470
leaq 0x8(%r14), %r15
pushq $0x1
popq %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x6470
movq 0x10(%r14), %rax
andq $0x0, 0x18(%rbx)
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x6528
movq %rax, 0x28(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x64f6
movq %r14, %rdi
callq 0x3440
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x334e
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x35d4
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_binary_op(unsigned long)
Expression *Parser::parse_binary_op(size_t binary_op_priority)
{
    if (binary_op_priority < binary_ops_count) {
        Expression *lhs = parse_binary_op(binary_op_priority + 1);

        if (tokens.count == 0 || tokens.items->type != binary_ops[binary_op_priority]) {
            return lhs;
        }

        expect_token_type(binary_ops[binary_op_priority]);
        tokens.chop(1);

        Expression *rhs = parse_binary_op(binary_op_priority + 1);

        Expression *op = memory->alloc<Expression>();
        op->offset = lhs->offset;
        op->kind = binary_op_kinds[binary_op_priority];
        op->binary_op.lhs = lhs;
        op->binary_op.rhs = rhs;
        return op;
    } else {
        return parse_primary();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
cmpq $0x7, %rsi
ja 0x3e4d
movq %rsi, %rbx
leaq 0x1(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x3da0
movq %rax, %r14
cmpq $0x0, 0x8(%r15)
je 0x3e3b
movq 0x10(%r15), %rax
movl (%rax), %esi
leaq 0x631c(%rip), %rax      # 0xa100
cmpl (%rax,%rbx,4), %esi
jne 0x3e3b
leaq 0x8(%r15), %r13
movq %r15, %rdi
callq 0x6470
pushq $0x1
popq %rsi
movq %r13, %rdi
movq %rsi, %r13
callq 0x64f6
movq %r15, %rdi
movq %r12, %rsi
callq 0x3da0
movq %rax, %r12
movq (%r15), %rdi
movq %r13, %rsi
callq 0x5ce2
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
leaq 0x62f5(%rip), %rcx      # 0xa120
movl (%rcx,%rbx,4), %ecx
movl %ecx, (%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c48
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_module()
Module Parser::parse_module()
{
    Module module = {};

    Top_Level_Def *last_top_level_def = nullptr;

    while (tokens.count > 0) {
        auto top_level_def = parse_top_level_def();

        if (module.top_level_defs == nullptr) {
            module.top_level_defs = top_level_def;
        } else {
            last_top_level_def->next = top_level_def;
        }

        last_top_level_def = top_level_def;
    }

    return module;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, %r15
cmpq $0x0, 0x8(%rbx)
je 0x3ef1
movq %rbx, %rdi
callq 0x3e64
testq %r14, %r14
je 0x3eec
movq %rax, 0x30(%r15)
movq %rax, %r15
jmp 0x3ecf
movq %rax, %r14
jmp 0x3ecc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: print1(_IO_FILE*, S_Expr*)
void print1(FILE *stream, S_Expr *expr)
{
    if (expr == nullptr) {
        print(stream, "()");
    } else {
        switch (expr->type) {
        case S_Expr_Type::Atom: {
            print(stream, expr->atom.name);
        } break;

        case S_Expr_Type::Cons: {
            print(stream, "(");
            bool first = false;
            while (expr && expr->type == S_Expr_Type::Cons) {
                if (!first) {
                    first = true;
                } else {
                    print(stream, " ");
                }
                print(stream, expr->cons.head);
                expr = expr->cons.tail;
            }

            if (expr) {
                print(stream, " . ", expr);
            }

            print(stream, ")");
        } break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3f39
movq %rsi, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x3f42
cmpl $0x1, %eax
jne 0x3f88
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12c0
leaq 0x4514(%rip), %rsi      # 0x8454
jmp 0x3fac
leaq 0x4a62(%rip), %rsi      # 0x89ab
movq %rbx, %rdi
callq 0x16f9
xorl %eax, %eax
leaq 0x4a49(%rip), %r15      # 0x89a3
testq %r14, %r14
je 0x3fa5
cmpl $0x0, (%r14)
jne 0x3f93
testb $0x1, %al
je 0x3f74
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16f9
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3eff
movq 0x10(%r14), %r14
movb $0x1, %al
jmp 0x3f5a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b9a(%rip), %rsi      # 0x8b34
movq %rbx, %rdi
movq %r14, %rdx
callq 0x66f4
leaq 0x44a9(%rip), %rsi      # 0x8455
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f9
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_args_list(Args_List*)
S_Expr *Wat_Compiler::compile_args_list(Args_List *args_list)
{
    S_Expr *result = nullptr;
    S_Expr *last = nullptr;

    while (args_list) {
        S_Expr *node = cons(compile_var_def(args_list->var_def), nullptr);

        if (result == nullptr) {
            result = node;
        } else {
            assert(last);
            assert(last->type == S_Expr_Type::Cons);
            last->cons.tail = node;
        }

        last = node;

        args_list = args_list->next;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x4101
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x403c
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x67d4
movq %rax, %rcx
testq %r15, %r15
je 0x40f5
testq %r12, %r12
je 0x412a
cmpl $0x0, (%r12)
jne 0x4111
movq %rax, 0x10(%r12)
movq %r15, %rcx
movq 0x18(%rbx), %rbx
movq %rcx, %r15
movq %rax, %r12
jmp 0x40af
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b42(%rip), %rdi      # 0x8c5a
leaq 0x4aaf(%rip), %rsi      # 0x8bce
leaq 0x4aff(%rip), %rcx      # 0x8c25
pushq $0x57
jmp 0x4141
leaq 0x4aef(%rip), %rdi      # 0x8c20
leaq 0x4a96(%rip), %rsi      # 0x8bce
leaq 0x4ae6(%rip), %rcx      # 0x8c25
pushq $0x56
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_rem(Binary_Op)
S_Expr *Wat_Compiler::compile_rem(Binary_Op rem)
{
    assert(rem.lhs->type == rem.rhs->type && "Type Checking step didn't work correctly.");
    switch (rem.lhs->type) {
    case Type::U0:
        assert(0 && "Type checking did not work correctly. There is no Rem operation defined for Type::U0.");
        break;
    case Type::Bool:
        assert(0 && "Type checking did not work correctly. There is no Rem operation defined for Type::Bool.");
        break;
    case Type::U8:
    case Type::U32:
        return list(atom("i32.rem_u"_sv), compile_expression(rem.lhs), compile_expression(rem.rhs));
    case Type::U64:
        return list(atom("i64.rem_u"_sv), compile_expression(rem.lhs), compile_expression(rem.rhs));
    case Type::Unchecked:
        assert(0 && "Unchecked type in a checked context");
        break;
    }

    assert(0 && "Memory corruption?");
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x42e7
cmpl $0x5, %eax
ja 0x4304
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x3e96(%rip), %rcx      # 0x8124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4b2e(%rip), %rdx      # 0x8dcc
jmp 0x42a7
leaq 0x4b2f(%rip), %rdx      # 0x8dd6
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x49a7(%rip), %rdi      # 0x8c95
leaq 0x48d9(%rip), %rsi      # 0x8bce
leaq 0x49e7(%rip), %rcx      # 0x8ce3
pushq $0x7d
popq %rdx
callq 0x1090
leaq 0x4b00(%rip), %rdi      # 0x8e0b
leaq 0x48bc(%rip), %rsi      # 0x8bce
leaq 0x49ca(%rip), %rcx      # 0x8ce3
movl $0x8f, %edx
callq 0x1090
leaq 0x4a43(%rip), %rdi      # 0x8d6d
leaq 0x489d(%rip), %rsi      # 0x8bce
leaq 0x49ab(%rip), %rcx      # 0x8ce3
movl $0x83, %edx
callq 0x1090
leaq 0x4a97(%rip), %rdi      # 0x8de0
leaq 0x487e(%rip), %rsi      # 0x8bce
leaq 0x498c(%rip), %rcx      # 0x8ce3
movl $0x8b, %edx
callq 0x1090
leaq 0x49a8(%rip), %rdi      # 0x8d10
leaq 0x485f(%rip), %rsi      # 0x8bce
leaq 0x496d(%rip), %rcx      # 0x8ce3
movl $0x80, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_expression(Expression*)
S_Expr *Wat_Compiler::compile_expression(Expression *expression)
{
    switch (expression->kind) {
    case Expression_Kind::Type_Cast:
        return compile_type_cast(expression->type_cast);
    case Expression_Kind::Number_Literal:
        return compile_number_literal(expression->number_literal);
    case Expression_Kind::Bool_Literal:
        return compile_bool_literal(expression->bool_literal);
    case Expression_Kind::Variable:
        return compile_variable(expression->variable);
    case Expression_Kind::Plus:
        return compile_plus(expression->binary_op);
    case Expression_Kind::Multiply:
        return compile_multiply(expression->binary_op);
    case Expression_Kind::Greater:
        return compile_greater(expression->binary_op);
    case Expression_Kind::Rem:
        return compile_rem(expression->binary_op);
    case Expression_Kind::Minus:
        return compile_minus(expression->binary_op);
    case Expression_Kind::And:
        return compile_and(expression->binary_op);
    case Expression_Kind::Less_Equals:
        return compile_less_equals(expression->binary_op);
    case Expression_Kind::Equals:
        return compile_equals(expression->binary_op);
    }

    assert(0 && "Memory corruption?");
    return nullptr;
}

// Assembly:
movl (%rsi), %eax
cmpq $0xb, %rax
ja 0x444b
leaq 0x3da9(%rip), %rcx      # 0x813c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsi), %rsi
jmp 0x418c
movl 0x10(%rsi), %esi
jmp 0x41d0
movl 0x10(%rsi), %eax
movq 0x18(%rsi), %rdx
movl %eax, %esi
jmp 0x4c8a
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4590
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x46b2
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4a18
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4260
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4216
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x47d4
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x446e
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x48f6
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4b3a
pushq %rbp
movq %rsp, %rbp
leaq 0x49b5(%rip), %rdi      # 0x8e0b
leaq 0x4771(%rip), %rsi      # 0x8bce
leaq 0x54a7(%rip), %rcx      # 0x990b
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x1090