LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x22b0
cmpq $0x0, -0x18(%rbp)
jne 0x2bd1
movl $0x1, -0x20(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x2bcf
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq 0xbe38(%rip), %rdx      # 0xe9ea
leaq 0xbe41(%rip), %r8       # 0xe9fa
movl $0x1, %r9d
leaq 0xbd17(%rip), %rax      # 0xe8dd
movq %rax, (%rsp)
callq 0xa3c0
jmp 0x2bd1
jmp 0x2bd3
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x2bee
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2bf7
jmp 0x2c17
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x2e80
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2bd3
cmpq $0x0, -0x18(%rbp)
je 0x2c2e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2e80
movq -0x28(%rbp), %rdi
callq 0x2310
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x26e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl $0x5, %edx
callq 0x2580
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x14(%rbp), %ecx
callq 0x2b60
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movl -0x14(%rbp), %ecx
callq 0x2b60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x26e0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x21e0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
callq 0x2580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x34(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x2d96
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %ecx
leaq 0xba54(%rip), %rdx      # 0xe7cd
leaq 0xbac8(%rip), %r8       # 0xe848
movl $0x1, %r9d
leaq 0xbb50(%rip), %rax      # 0xe8dd
movq %rax, (%rsp)
callq 0xa3c0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, -0x19(%rbp)
je 0x2dce
movb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x2dce
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2dd7
jmp 0x2dd9
jmp 0x2df8
leaq 0xbb61(%rip), %rdi      # 0xe941
leaq 0xb85a(%rip), %rsi      # 0xe641
movl $0xfd, %edx
leaq 0xbba1(%rip), %rcx      # 0xe994
callq 0x10c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x26e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq 0x30(%rdi), %rax
movl 0x18(%rax), %edx
callq 0x2580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
je 0x2e6c
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %ecx
leaq 0xb97e(%rip), %rdx      # 0xe7cd
leaq 0xbb77(%rip), %r8       # 0xe9cd
movl $0x1, %r9d
leaq 0xba7a(%rip), %rax      # 0xe8dd
movq %rax, (%rsp)
callq 0xa3c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x2f5f
movq -0x20(%rbp), %rax
leaq 0xb1a2(%rip), %rcx      # 0xe05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x2600
jmp 0x2f5f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x2ab0
jmp 0x2f5f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x2c40
jmp 0x2f5f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x2cd0
jmp 0x2f5f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x26e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x2580
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2f5f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl -0x14(%rbp), %edx
callq 0x2da0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, -0x11(%rbp)
jne 0x2f9b
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x2f9b
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x2fa4
jmp 0x2fa6
jmp 0x2fc5
leaq 0xbacf(%rip), %rdi      # 0xea7c
leaq 0xb68d(%rip), %rsi      # 0xe641
movl $0x13f, %edx            # imm = 0x13F
leaq 0xbb42(%rip), %rcx      # 0xeb02
callq 0x10c0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x30(%rdi)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x22b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
callq 0x2b60
movq -0x20(%rbp), %rdi
movq $0x0, 0x30(%rdi)
callq 0x2310
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3065
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2f70
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3043
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xa8f7(%rip), %rsi      # 0xec95
callq 0xa050
cmpq $0x0, -0x10(%rbp)
je 0x43fc
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x30, %edx
callq 0x10d0
movq -0x48(%rbp), %rdi
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xa8a4(%rip), %rsi      # 0xec8d
callq 0xa7f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x43a3
movq -0x8(%rbp), %rdi
leaq 0xa272(%rip), %rsi      # 0xe679
callq 0xa050
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x4576
movq -0x18(%rbp), %rax
leaq 0x9dbd(%rip), %rcx      # 0xe248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xa6e2(%rip), %rsi      # 0xeb81
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa7ec(%rip), %rsi      # 0xeca0
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa6e1(%rip), %rsi      # 0xebaa
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa6b8(%rip), %rsi      # 0xeb96
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa7b6(%rip), %rsi      # 0xeca9
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa699(%rip), %rsi      # 0xeb9e
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa6a5(%rip), %rsi      # 0xebbc
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa6ad(%rip), %rsi      # 0xebd6
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa697(%rip), %rsi      # 0xebd2
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa766(%rip), %rsi      # 0xecb3
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa693(%rip), %rsi      # 0xebf2
callq 0xa050
jmp 0x4576
movq -0x8(%rbp), %rdi
leaq 0xa74b(%rip), %rsi      # 0xecbc
callq 0xa050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9b87(%rip), %rsi      # 0xec95
callq 0xa050
cmpq $0x0, -0x10(%rbp)
je 0x516c
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x30, %edx
callq 0x10d0
movq -0x48(%rbp), %rdi
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x9b34(%rip), %rsi      # 0xec8d
callq 0xaf20
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5113
movq -0x8(%rbp), %rdi
leaq 0x9502(%rip), %rsi      # 0xe679
callq 0xa050
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x522a
movq -0x18(%rbp), %rax
leaq 0x9109(%rip), %rcx      # 0xe2c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x96b2(%rip), %rsi      # 0xe87d
callq 0xa050
jmp 0x522a
movq -0x8(%rbp), %rdi
leaq 0x9b38(%rip), %rsi      # 0xed15
callq 0xa050
jmp 0x522a
movq -0x8(%rbp), %rdi
leaq 0x9b29(%rip), %rsi      # 0xed18
callq 0xa050
jmp 0x522a
movq -0x8(%rbp), %rdi
leaq 0x9b1a(%rip), %rsi      # 0xed1b
callq 0xa050
jmp 0x522a
movq -0x8(%rbp), %rdi
leaq 0x9b0c(%rip), %rsi      # 0xed1f
callq 0xa050
jmp 0x522a
movq -0x8(%rbp), %rdi
leaq 0x9afe(%rip), %rsi      # 0xed23
callq 0xa050
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x99ea(%rip), %rsi      # 0xec95
callq 0xa050
cmpq $0x0, -0x10(%rbp)
je 0x530d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rax
leaq 0x99ac(%rip), %rsi      # 0xec8d
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xb010
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x52b0
movq -0x8(%rbp), %rdi
leaq 0x9361(%rip), %rsi      # 0xe679
callq 0xa050
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x20(%rbp), %rdi
callq 0x5430
movq -0x18(%rbp), %rdi
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x4, %esi
callq 0xb150
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x78(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x988b(%rip), %rdi      # 0xed1b
movl $0x3, %esi
callq 0x12e0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x54b9
jmp 0x54d7
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movl $0x3, -0x4(%rbp)
jmp 0x5604
leaq 0x9841(%rip), %rdi      # 0xed1f
movl $0x3, %esi
callq 0x12e0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x5507
jmp 0x5525
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movl $0x4, -0x4(%rbp)
jmp 0x5604
leaq 0x97ec(%rip), %rdi      # 0xed18
movl $0x2, %esi
callq 0x12e0
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x5555
jmp 0x5573
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movl $0x2, -0x4(%rbp)
jmp 0x5604
leaq 0x97a9(%rip), %rdi      # 0xed23
movl $0x4, %esi
callq 0x12e0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x55a3
jmp 0x55be
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movl $0x5, -0x4(%rbp)
jmp 0x5604
movq -0x78(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x80(%rbp)
callq 0xb270
movq -0x80(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
leaq 0x973b(%rip), %rdx      # 0xed33
leaq 0x92de(%rip), %r9       # 0xe8dd
callq 0xa110
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x2, %esi
callq 0xb150
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x570f
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa240
movq -0x48(%rbp), %rsi
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x53b0
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x56ad
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x56b9
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
cmpl $0x5, (%rax)
je 0x56f8
movq -0x48(%rbp), %rdi
movl $0x3, %esi
callq 0xb150
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5717
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
jmp 0x5650
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x10(%rbp), %rdi
movl $0x16, %esi
callq 0xb150
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0xb150
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rdi
callq 0x5830
movq -0x10(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, %esi
callq 0xb150
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rdi
callq 0x5880
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rdi)
cmpq $0x0, 0x8(%rax)
jbe 0x5820
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x17, (%rax)
jne 0x5820
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rdi
callq 0x5880
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl $0x6, %esi
callq 0xb150
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x58(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x59(%rbp)
jbe 0x58e1
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, (%rax)
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x58ea
jmp 0x5948
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xb2d0
movq -0x58(%rbp), %rsi
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5e60
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0x10d0
cmpq $0x0, -0x18(%rbp)
jne 0x592f
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x593b
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x58c0
movq -0x58(%rbp), %rdi
movl $0x7, %esi
callq 0xb150
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movl $0xc, %esi
callq 0xb150
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
movl $0x1, %esi
movq %rsi, -0x28(%rbp)
callq 0xb210
movq -0x20(%rbp), %rdi
movl $0x2, %esi
callq 0xb150
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb210
movq -0x20(%rbp), %rdi
callq 0x5830
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movl $0x3, %esi
callq 0xb150
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xb210
movq -0x20(%rbp), %rdi
callq 0x5880
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x21(%rbp)
jbe 0x5a5d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x13, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5a66
jmp 0x5a7a
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
jmp 0x5a3c
movq -0x10(%rbp), %rdi
movl $0x13, %esi
callq 0xb150
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rdi
movl $0x9, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rdi
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x13, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rdi
movl $0x11, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa300
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rdi)
movq 0x10(%rdi), %rcx
movl $0x2, (%rcx)
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa300
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movq 0x10(%rcx), %rax
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x13, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa300
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rdi)
movq 0x10(%rdi), %rcx
movl $0x6, (%rcx)
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa300
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdi
movq %rax, %rdx
movq 0x10(%rcx), %rax
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
movq 0x10(%rcx), %rax
movq 0x10(%rax), %rax
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movl $0x13, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x19, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10b0
movq -0x18(%rbp), %rdi
callq 0x5830
movq -0x18(%rbp), %rdi
movq %rax, -0x8(%rbp)
movl $0x13, %esi
callq 0xb150
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x10b0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0xb150
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x53b0
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x9, %esi
callq 0xb150
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x30(%rbp), %rdi
callq 0x5830
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x13, %esi
callq 0xb150
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xb150
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0xb150
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
callq 0xb270
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x20(%rbp), %rdi
callq 0x5610
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x5430
movq -0x20(%rbp), %rdi
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
callq 0x5880
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x6719
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x6610
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x6670
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rdx
leaq 0x7f25(%rip), %rcx      # 0xe590
cmpl (%rcx,%rdx,4), %eax
je 0x667d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6726
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x7f04(%rip), %rax      # 0xe590
movl (%rax,%rcx,4), %esi
callq 0xb150
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0xb210
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x6610
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movl $0x1, %esi
callq 0xa300
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
leaq 0x7ec2(%rip), %rax      # 0xe5b0
movl (%rax,%rcx,4), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6726
movq -0x38(%rbp), %rdi
callq 0x63c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10b0
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x67eb
movq -0x28(%rbp), %rdi
callq 0x6730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x67d5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x67e1
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x67ac
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x682c
movq -0x8(%rbp), %rdi
leaq 0x7e56(%rip), %rsi      # 0xe678
callq 0xa050
jmp 0x6911
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x6873
jmp 0x683b
movl -0x28(%rbp), %eax
subl $0x1, %eax
jne 0x690f
jmp 0x6849
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa990
jmp 0x690f
movq -0x8(%rbp), %rdi
leaq 0x8417(%rip), %rsi      # 0xec95
callq 0xa050
movb $0x0, -0x21(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x68a0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x68a9
jmp 0x68e4
testb $0x1, -0x21(%rbp)
jne 0x68b5
movb $0x1, -0x21(%rbp)
jmp 0x68c5
movq -0x8(%rbp), %rdi
leaq 0x83cd(%rip), %rsi      # 0xec8d
callq 0xa050
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb550
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6887
cmpq $0x0, -0x10(%rbp)
je 0x68ff
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x8524(%rip), %rsi      # 0xee1e
callq 0xb580
movq -0x8(%rbp), %rdi
leaq 0x7d6f(%rip), %rsi      # 0xe679
callq 0xa050
jmp 0x6911
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x60(%rbp)
subq $0x5, %rax
ja 0x6abe
movq -0x60(%rbp), %rax
leaq 0x79d5(%rip), %rcx      # 0xe3a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8441(%rip), %rdi      # 0xee24
leaq 0x84ce(%rip), %rsi      # 0xeeb8
movl $0x2e, %edx
leaq 0x84dd(%rip), %rcx      # 0xeed3
callq 0x10c0
leaq 0x9219(%rip), %rdi      # 0xfc1b
movl $0x3, %esi
callq 0x12e0
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb5c0
movq %rax, -0x8(%rbp)
jmp 0x6ac6
leaq 0x91e6(%rip), %rdi      # 0xfc1b
movl $0x3, %esi
callq 0x12e0
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xb5c0
movq %rax, -0x8(%rbp)
jmp 0x6ac6
leaq 0x849b(%rip), %rdi      # 0xef00
movl $0x3, %esi
callq 0x12e0
movq -0x68(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xb5c0
movq %rax, -0x8(%rbp)
jmp 0x6ac6
leaq 0x9186(%rip), %rdi      # 0xfc1b
movl $0x3, %esi
callq 0x12e0
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xb5c0
movq %rax, -0x8(%rbp)
jmp 0x6ac6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq