LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e94
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1b7c
movq %r14, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x1d7e
movq %rax, 0x10(%r15)
cmpl $0x1, %ebx
jne 0x23ae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
movq 0x8(%rax), %rsi
leaq 0x72e4(%rip), %rax      # 0x96a1
movq %rax, (%rsp)
leaq 0x71c9(%rip), %rdx      # 0x9591
leaq 0x723d(%rip), %r8       # 0x960c
movq %r14, %rdi
movl %ebx, %ecx
movl $0x1, %r9d
callq 0x6fce
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2430
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
movq %r12, %rsi
callq 0x1e94
movq 0x30(%r14), %rax
movl 0x18(%rax), %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d7e
movq %rax, (%r15)
cmpl $0x1, %ebx
jne 0x244f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7291(%rip), %rdi      # 0x96c8
leaq 0x6feb(%rip), %rsi      # 0x9429
leaq 0x72d6(%rip), %rcx      # 0x971b
movl $0xfd, %edx
callq 0x1090
addq $0x8, %r14
movq 0x8(%rax), %rsi
leaq 0x7243(%rip), %rax      # 0x96a1
movq %rax, (%rsp)
leaq 0x7128(%rip), %rdx      # 0x9591
leaq 0x72e4(%rip), %r8       # 0x9754
movq %r14, %rdi
movl %ebx, %ecx
movl $0x1, %r9d
callq 0x6fce
// File: /workspace/github_cpp_makefile_star2_O3/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 0x251f
movq %rdi, %r15
leaq 0x6bb6(%rip), %rcx      # 0x905c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x1dfe
jmp 0x251f
movq 0x10(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1e94
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x1d7e
movq %rax, 0x10(%r14)
jmp 0x251f
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x22f0
jmp 0x251f
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x2350
jmp 0x251f
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x2176
jmp 0x251f
leaq 0x10(%r14), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x23e0
movl %ebx, 0x4(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x30(%rdi)
jne 0x259f
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x30(%rdi)
movq 0x10(%rsi), %r15
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x6e36
movq %r15, (%rax)
movq 0x28(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x28(%rbx)
movq 0x28(%r14), %rsi
movq 0x20(%r14), %rdx
movl 0x18(%r14), %ecx
movq %rbx, %rdi
callq 0x2206
movq $0x0, 0x30(%rbx)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x25be
movq 0x8(%rax), %rax
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x71f8(%rip), %rdi      # 0x979e
leaq 0x6e7c(%rip), %rsi      # 0x9429
leaq 0x7270(%rip), %rcx      # 0x9824
movl $0x13f, %edx            # imm = 0x13F
callq 0x1090
leaq 0x6e5e(%rip), %rdi      # 0x9423
leaq 0x6e5d(%rip), %rsi      # 0x9429
leaq 0x6e71(%rip), %rcx      # 0x9444
movl $0x20, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
movq %rbx, %rsi
callq 0x1100
testq %r14, %r14
je 0x3308
leaq 0x61ad(%rip), %r13      # 0x9461
leaq 0x66f4(%rip), %r15      # 0x99af
leaq 0x6788(%rip), %r12      # 0x9a4a
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r9
movl 0x18(%r14), %eax
subq $0x8, %rsp
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %r8
pushq %r13
pushq 0x20(%r14)
pushq %r15
pushq %rax
pushq %r15
callq 0x77a8
addq $0x30, %rsp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x32c2
movl $0x29, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Expression_Kind)
void print1(FILE *stream, Expression_Kind expression_kind)
{
    switch (expression_kind) {
    case Expression_Kind::Number_Literal:
        print(stream, "Number_Literal");
        break;
    case Expression_Kind::Variable:
        print(stream, "Variable");
        break;
    case Expression_Kind::Plus:
        print(stream, "Plus");
        break;
    case Expression_Kind::Greater:
        print(stream, "Greater");
        break;
    case Expression_Kind::Type_Cast:
        print(stream, "Type_Cast");
        break;
    case Expression_Kind::Less_Equals:
        print(stream, "Less_Equals");
        break;
    case Expression_Kind::Minus:
        print(stream, "Minus");
        break;
    case Expression_Kind::Rem:
        print(stream, "Rem");
        break;
    case Expression_Kind::And:
        print(stream, "And");
        break;
    case Expression_Kind::Multiply:
        print(stream, "Multiply");
        break;
    case Expression_Kind::Equals:
        print(stream, "Equals");
        break;
    case Expression_Kind::Bool_Literal:
        print(stream, "Bool_Literal");
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xb, %esi
ja 0x343d
movq %rdi, %rcx
movl %esi, %eax
leaq 0x5e09(%rip), %rdx      # 0x9160
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x653c(%rip), %rdi      # 0x98a3
movl $0x1, %esi
movl $0xe, %edx
jmp 0x3437
leaq 0x6661(%rip), %rdi      # 0x99de
movl $0x1, %esi
movl $0xc, %edx
jmp 0x3437
leaq 0x6638(%rip), %rdi      # 0x99cb
movl $0x1, %esi
movl $0x9, %edx
jmp 0x3437
leaq 0x662c(%rip), %rdi      # 0x99d5
jmp 0x33e1
leaq 0x651a(%rip), %rdi      # 0x98cc
movl $0x1, %esi
movl $0x4, %edx
jmp 0x3437
leaq 0x64f3(%rip), %rdi      # 0x98b8
movl $0x1, %esi
movl $0x7, %edx
jmp 0x3437
leaq 0x6520(%rip), %rdi      # 0x98f8
jmp 0x342d
leaq 0x65e1(%rip), %rdi      # 0x99c2
movl $0x1, %esi
movl $0x8, %edx
jmp 0x3437
leaq 0x64cc(%rip), %rdi      # 0x98c0
movl $0x1, %esi
movl $0xb, %edx
jmp 0x3437
leaq 0x64d7(%rip), %rdi      # 0x98de
movl $0x1, %esi
movl $0x5, %edx
jmp 0x3437
leaq 0x64fa(%rip), %rdi      # 0x9914
movl $0x1, %esi
movl $0x6, %edx
jmp 0x3437
leaq 0x64c7(%rip), %rdi      # 0x98f4
movl $0x1, %esi
movl $0x3, %edx
popq %rbp
jmp 0x1190
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3829
leaq 0x10(%rbp), %rax
leaq 0x5ad9(%rip), %rdx      # 0x91c0
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 0x6305(%rip), %rsi      # 0x9a22
leaq 0x628b(%rip), %rdx      # 0x99af
leaq 0x5d36(%rip), %rcx      # 0x9461
callq 0x74bd
jmp 0x3829
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x343f
jmp 0x3829
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 0x5ceb(%rip), %rax      # 0x9461
movq %rax, 0x20(%rsp)
leaq 0x6293(%rip), %rsi      # 0x9a15
leaq 0x6226(%rip), %rdx      # 0x99af
movq %rdx, %r8
callq 0x7346
jmp 0x3829
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 0x6271(%rip), %rsi      # 0x9a2a
leaq 0x61ef(%rip), %r8       # 0x99af
leaq 0x5c9a(%rip), %r9       # 0x9461
callq 0x757b
jmp 0x3829
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x622d(%rip), %rsi      # 0x9a1a
leaq 0x61bb(%rip), %rdx      # 0x99af
leaq 0x5c66(%rip), %r8       # 0x9461
callq 0x741a
jmp 0x3829
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x6211(%rip), %rsi      # 0x9a2e
leaq 0x5c3d(%rip), %rdx      # 0x9461
callq 0x762e
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
movq %rbx, %rsi
callq 0x1100
testq %r14, %r14
je 0x3889
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 0x36c7
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movq 0x30(%r14), %r14
jmp 0x384d
movl $0x29, %edi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: print1(_IO_FILE*, Type)
void print1(FILE *stream, Type type)
{
    switch (type) {
    case Type::Unchecked:
        print(stream, "Type::Unchecked");
        break;
    case Type::U0:
        print(stream, "u0");
        break;
    case Type::U8:
        print(stream, "u8");
        break;
    case Type::U32:
        print(stream, "u32");
        break;
    case Type::U64:
        print(stream, "u64");
        break;
    case Type::Bool:
        print(stream, "bool");
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x5, %esi
ja 0x391e
movq %rdi, %rcx
movl %esi, %eax
leaq 0x5925(%rip), %rdx      # 0x91d8
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x5d7e(%rip), %rdi      # 0x9641
movl $0x1, %esi
movl $0xf, %edx
jmp 0x3918
leaq 0x616b(%rip), %rdi      # 0x9a41
jmp 0x38e8
leaq 0x615b(%rip), %rdi      # 0x9a3a
jmp 0x38fb
leaq 0x6155(%rip), %rdi      # 0x9a3d
movl $0x1, %esi
movl $0x3, %edx
jmp 0x3918
leaq 0x613c(%rip), %rdi      # 0x9a37
movl $0x1, %esi
movl $0x2, %edx
jmp 0x3918
leaq 0x6137(%rip), %rdi      # 0x9a45
movl $0x1, %esi
movl $0x4, %edx
popq %rbp
jmp 0x1190
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x28, %edi
movq %rbx, %rsi
callq 0x1100
testq %r14, %r14
je 0x39a9
leaq 0x602b(%rip), %r15      # 0x99af
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x774a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3984
movl $0x29, %edi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%r14), %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rbx)
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%r14), %rdx
testq %rdx, %rdx
movl $0x18, %esi
cmoveq %rdx, %rsi
addq %rax, %rsi
subq $0x1, %rdx
cmovbq %rcx, %rdx
movq %rsi, 0x10(%r14)
movq %rdx, 0x8(%r14)
movq %r14, %rdi
callq 0x3a64
movl %eax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movl $0x4, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %edx, %edx
subq $0x1, %rax
cmovaeq %rax, %rdx
addq %rcx, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%rbx), %rcx
movq 0x8(%rcx), %r14
movq 0x10(%rcx), %r15
cmpq $0x2, %r14
je 0x3b0d
cmpq $0x4, %r14
je 0x3afd
cmpq $0x3, %r14
jne 0x3b1a
movzwl (%r15), %eax
xorl $0x3375, %eax           # imm = 0x3375
movzbl 0x2(%r15), %edx
xorl $0x32, %edx
orw %ax, %dx
je 0x3b45
movzwl (%r15), %edx
xorl $0x3675, %edx           # imm = 0x3675
movzbl 0x2(%r15), %esi
xorl $0x34, %esi
movl $0x4, %eax
orw %dx, %si
je 0x3b4a
jmp 0x3b1a
movl $0x5, %eax
cmpl $0x6c6f6f62, (%r15)     # imm = 0x6C6F6F62
je 0x3b4a
jmp 0x3b1a
movl $0x2, %eax
cmpw $0x3875, (%r15)         # imm = 0x3875
je 0x3b4a
leaq 0x18(%rbx), %r12
movq %rbx, %rdi
callq 0x794a
leaq 0x5f28(%rip), %rdx      # 0x9a55
leaq 0x5b6d(%rip), %r9       # 0x96a1
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x6e08
movl $0x3, %eax
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
movl $0x18, %esi
cmoveq %rdx, %rsi
addq %rsi, %rcx
xorl %esi, %esi
subq $0x1, %rdx
cmovaeq %rdx, %rsi
movq %rcx, 0x10(%rbx)
movq %rsi, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq %rdi, %rbx
movl $0x2, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3c1b
addq $0x18, 0x10(%rbx)
decq %rax
movq %rax, 0x8(%rbx)
je 0x3c1b
xorl %r13d, %r13d
xorl %r14d, %r14d
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x6ebe
movq %rax, %r12
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x3a02
movq -0x30(%rbp), %rax
movq %rax, 0x10(%r12)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%r12)
movq %r12, %r15
testq %r13, %r13
je 0x3bf0
movq %r12, 0x18(%r13)
movq %r14, %r15
movq 0x10(%rbx), %rcx
cmpl $0x5, (%rcx)
jne 0x3c30
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3c1e
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
movq %r12, %r13
movq %r15, %r14
decq %rax
movq %rax, 0x8(%rbx)
jne 0x3bb3
jmp 0x3c1e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x3, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %edx, %edx
subq $0x1, %rax
cmovaeq %rax, %rdx
addq %rcx, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
jmp 0x3c1e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %r15d, %r15d
movq %r15, 0x10(%rdi)
movq %rsi, %rdi
movl $0x16, %esi
callq 0x78c4
movq 0x8(%r14), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
movl $0x18, %r12d
subq $0x1, %rax
cmovbq %r15, %rax
addq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x2, %esi
callq 0x78c4
movq 0x8(%r14), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
subq $0x1, %rax
cmovbq %r15, %rax
addq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3d52
movq %rax, (%rbx)
movq %r14, %rdi
movl $0x3, %esi
callq 0x78c4
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %rax, %r12
subq $0x1, %rax
cmovbq %r15, %rax
addq %r12, 0x10(%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3d84
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3d46
movq 0x10(%r14), %rcx
cmpl $0x17, (%rcx)
jne 0x3d46
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3d84
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x6, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3e1f
addq $0x18, 0x10(%rbx)
decq %rax
movq %rax, 0x8(%rbx)
je 0x3e1f
xorl %r13d, %r13d
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
cmpl $0x7, (%rax)
je 0x3e24
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x79aa
movq %rax, %r12
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x42f6
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq %r12, %r15
testq %r14, %r14
je 0x3e10
movq %r12, 0x30(%r14)
movq %r13, %r15
cmpq $0x0, 0x8(%rbx)
movq %r15, %r13
movq %r12, %r14
jne 0x3dbf
jmp 0x3e27
xorl %r15d, %r15d
jmp 0x3e27
movq %r13, %r15
movq %rbx, %rdi
movl $0x7, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %edx, %edx
subq $0x1, %rax
cmovaeq %rax, %rdx
addq %rcx, 0x10(%rbx)
movq %rdx, 0x8(%rbx)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xc, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %r15d
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %r12d, %r12d
subq $0x1, %rax
cmovbq %r12, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
subq $0x1, %rax
cmovbq %r12, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3d52
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r15
subq $0x1, %rax
cmovbq %r12, %rax
addq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3d84
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3f59
movq 0x10(%r14), %rcx
addq $0x18, %rcx
decq %rax
cmpl $0x13, -0x18(%rcx)
je 0x3f59
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
addq $0x18, %rcx
addq $-0x1, %rax
jb 0x3f41
movq %r14, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%r14), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %edx, %edx
subq $0x1, %rax
cmovaeq %rax, %rdx
addq %rcx, 0x10(%r14)
movq %rdx, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%rbx), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
movl $0x18, %edx
cmoveq %rcx, %rdx
movl $0x18, %r15d
addq %rax, %rdx
xorl %r12d, %r12d
subq $0x1, %rcx
cmovbq %r12, %rcx
movq %rdx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rdi
movl $0x9, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
subq $0x1, %rax
cmovbq %r12, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3d52
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r15
subq $0x1, %rax
cmovbq %r12, %rax
addq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%rbx), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
movl $0x18, %edx
cmoveq %rcx, %rdx
movl $0x18, %r12d
addq %rax, %rdx
xorl %r13d, %r13d
subq $0x1, %rcx
cmovbq %r13, %rcx
movq %rdx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rdi
movl $0x11, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
movq (%rbx), %rdi
subq $0x1, %rax
cmovbq %r13, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movl $0x1, %esi
callq 0x6f46
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x2, (%rax)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x6f46
movq %rax, 0x10(%r15)
movl $0x1, (%rax)
movq 0x10(%r15), %rax
movups (%r14), %xmm0
movups %xmm0, 0x10(%rax)
movq %rbx, %rdi
callq 0x3d52
movq %rax, 0x18(%r15)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r12
subq $0x1, %rax
cmovbq %r13, %rax
addq %r12, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_parser.cpp
// Function: Parser::parse_subtract_assignment()
Assignment Parser::parse_subtract_assignment()
{
    Assignment assignment = {};

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

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

    assignment.value = memory->alloc<Expression>();
    assignment.value->kind = Expression_Kind::Minus;
    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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%rbx), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
movl $0x18, %edx
cmoveq %rcx, %rdx
movl $0x18, %r12d
addq %rax, %rdx
xorl %r13d, %r13d
subq $0x1, %rcx
cmovbq %r13, %rcx
movq %rdx, 0x10(%rbx)
movq %rcx, 0x8(%rbx)
movq %rbx, %rdi
movl $0x10, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
movq (%rbx), %rdi
subq $0x1, %rax
cmovbq %r13, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movl $0x1, %esi
callq 0x6f46
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x6, (%rax)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x6f46
movq %rax, 0x10(%r15)
movl $0x1, (%rax)
movq 0x10(%r15), %rax
movups (%r14), %xmm0
movups %xmm0, 0x10(%rax)
movq %rbx, %rdi
callq 0x3d52
movq %rax, 0x18(%r15)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r12
subq $0x1, %rax
cmovbq %r13, %rax
addq %r12, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x19, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %r15d
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %r12d, %r12d
subq $0x1, %rax
cmovbq %r12, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3d52
movq %rax, %r14
movq %rbx, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r15
subq $0x1, %rax
cmovbq %r12, %rax
addq %r15, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r15, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movl $0x8, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
movl $0x18, %r12d
subq $0x1, %rax
cmovbq %r15, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a02
movq %rbx, %rdi
movl $0x9, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
subq $0x1, %rax
cmovbq %r15, %rax
addq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3d52
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x78c4
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %rax, %r12
subq $0x1, %rax
cmovbq %r15, %rax
addq %r12, 0x10(%rbx)
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %r15d, %r15d
movq %r15, 0x18(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x78c4
movq 0x8(%r14), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
movl $0x18, %r12d
subq $0x1, %rax
cmovbq %r15, %rax
addq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x78c4
movq 0x10(%r14), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x794a
movq %rax, 0x28(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %rax, %r12
subq $0x1, %rax
cmovbq %r15, %rax
addq %r12, 0x10(%r14)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3b78
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x3a64
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x3d84
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %r15
cmpq $0x7, %rsi
ja 0x4860
movq %rsi, %rbx
leaq 0x1(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x47aa
movq %rax, %r14
cmpq $0x0, 0x8(%r15)
je 0x4854
movq 0x10(%r15), %rax
movl (%rax), %esi
leaq 0x6925(%rip), %rax      # 0xb110
cmpl (%rax,%rbx,4), %esi
jne 0x4854
movq %r15, %rdi
callq 0x78c4
movq 0x8(%r15), %rax
testq %rax, %rax
movl $0x18, %ecx
cmoveq %rax, %rcx
xorl %edx, %edx
subq $0x1, %rax
cmovaeq %rax, %rdx
addq %rcx, 0x10(%r15)
movq %rdx, 0x8(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x47aa
movq %rax, %r12
movq (%r15), %rdi
movl $0x1, %esi
callq 0x6f46
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
leaq 0x68ec(%rip), %rcx      # 0xb130
movl (%rcx,%rbx,4), %ecx
movl %ecx, (%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x460c
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpq $0x0, 0x8(%rdi)
je 0x494f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
leaq -0x58(%rbp), %r14
xorl %r13d, %r13d
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7ad0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4556
movups -0x58(%rbp), %xmm0
movups -0x48(%rbp), %xmm1
movups -0x38(%rbp), %xmm2
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq %r15, %rax
testq %r12, %r12
je 0x4933
movq %r15, 0x30(%r13)
movq %r12, %rax
cmpq $0x0, 0x8(%rbx)
movq %rax, %r12
movq %r15, %r13
jne 0x48ef
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x497e
movq %rsi, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x499b
cmpl $0x1, %eax
jne 0x49da
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rdi
movl $0x1, %esi
jmp 0x498f
leaq 0x4adb(%rip), %rdi      # 0x9460
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x1190
movl $0x28, %edi
movq %rbx, %rsi
callq 0x1100
xorl %eax, %eax
cmpl $0x0, (%r14)
jne 0x49df
testb $0x1, %al
je 0x49c1
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4952
movq 0x10(%r14), %r14
movb $0x1, %al
testq %r14, %r14
jne 0x49aa
jmp 0x4a03
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x515a(%rip), %rdi      # 0x9b40
movl $0x1, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4952
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::wat_name_of_type(Type)
S_Expr *Wat_Compiler::wat_name_of_type(Type type)
{
    switch (type) {
    case Type::Unchecked:
    case Type::U0:
        assert(0 && "Something went horribly wrong. Such value should never reach here. Trying to compile a type that does not have a WebAssembly representation.");
        break;

    case Type::U8:
        return atom("i32"_sv);
        break;

    case Type::U32:
        return atom("i32"_sv);
        break;

    case Type::U64:
        return atom("i64"_sv);
        break;

    case Type::Bool:
        return atom("i32"_sv);
        break;
    }
    return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x5, %esi
ja 0x4ab4
movl $0x2c, %eax
btl %esi, %eax
jae 0x4a82
leaq 0x5e93(%rip), %rbx      # 0xa913
jmp 0x4a8e
cmpl $0x4, %esi
jne 0x4ab8
leaq 0x5194(%rip), %rbx      # 0x9c22
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x1, (%rax)
movq $0x3, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x4aad
leaq 0x5087(%rip), %rdi      # 0x9b46
leaq 0x5114(%rip), %rsi      # 0x9bda
leaq 0x5128(%rip), %rcx      # 0x9bf5
movl $0x2e, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x4c27
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4ad8
movq %rax, %r15
movq (%r14), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r15, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rcx
testq %r13, %r13
je 0x4c16
testq %r12, %r12
je 0x4c3b
cmpl $0x0, (%r12)
jne 0x4c5a
movq %rax, 0x10(%r12)
movq %r13, %rcx
movq 0x18(%rbx), %rbx
movq %rax, %r12
movq %rcx, %r13
testq %rbx, %rbx
jne 0x4bc0
jmp 0x4c29
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4fea(%rip), %rdi      # 0x9c2c
leaq 0x4f91(%rip), %rsi      # 0x9bda
leaq 0x4fe1(%rip), %rcx      # 0x9c31
movl $0x56, %edx
callq 0x1090
leaq 0x5005(%rip), %rdi      # 0x9c66
leaq 0x4f72(%rip), %rsi      # 0x9bda
leaq 0x4fc2(%rip), %rcx      # 0x9c31
movl $0x57, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x4ef2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x4e5a
leaq 0x4f80(%rip), %r13      # 0x9dd8
jmp 0x4e7c
cmpl $0x5, %eax
ja 0x4f30
movl %eax, %eax
leaq 0x4384(%rip), %rcx      # 0x91f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4f66(%rip), %r13      # 0x9de2
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x9, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4da8(%rip), %rdi      # 0x9ca1
leaq 0x4cda(%rip), %rsi      # 0x9bda
leaq 0x4de8(%rip), %rcx      # 0x9cef
movl $0x7d, %edx
callq 0x1090
leaq 0x4e61(%rip), %rdi      # 0x9d79
leaq 0x4cbb(%rip), %rsi      # 0x9bda
leaq 0x4dc9(%rip), %rcx      # 0x9cef
movl $0x83, %edx
callq 0x1090
leaq 0x4ee0(%rip), %rdi      # 0x9e17
leaq 0x4c9c(%rip), %rsi      # 0x9bda
leaq 0x4daa(%rip), %rcx      # 0x9cef
movl $0x8f, %edx
callq 0x1090
leaq 0x4dc6(%rip), %rdi      # 0x9d1c
leaq 0x4c7d(%rip), %rsi      # 0x9bda
leaq 0x4d8b(%rip), %rcx      # 0x9cef
movl $0x80, %edx
callq 0x1090
leaq 0x4e77(%rip), %rdi      # 0x9dec
leaq 0x4c5e(%rip), %rsi      # 0x9bda
leaq 0x4d6c(%rip), %rcx      # 0x9cef
movl $0x8b, %edx
callq 0x1090
nop