LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37ed
leaq 0x10(%rbp), %rax
leaq 0x6b01(%rip), %rdx      # 0xa1ac
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 0x7321(%rip), %rsi      # 0xaa02
leaq 0x72a7(%rip), %rdx      # 0xa98f
leaq 0x6d52(%rip), %rcx      # 0xa441
callq 0x7759
jmp 0x37ed
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x3403
jmp 0x37ed
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 0x6d07(%rip), %rax      # 0xa441
movq %rax, 0x20(%rsp)
leaq 0x72af(%rip), %rsi      # 0xa9f5
leaq 0x7242(%rip), %rdx      # 0xa98f
movq %rdx, %r8
callq 0x75e2
jmp 0x37ed
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 0x728d(%rip), %rsi      # 0xaa0a
leaq 0x720b(%rip), %r8       # 0xa98f
leaq 0x6cb6(%rip), %r9       # 0xa441
callq 0x7817
jmp 0x37ed
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x7249(%rip), %rsi      # 0xa9fa
leaq 0x71d7(%rip), %rdx      # 0xa98f
leaq 0x6c82(%rip), %r8       # 0xa441
callq 0x76b6
jmp 0x37ed
movq 0x10(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x722d(%rip), %rsi      # 0xaa0e
leaq 0x6c59(%rip), %rdx      # 0xa441
callq 0x78ca
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x384d
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 0x368b
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movq 0x30(%r14), %r14
jmp 0x3811
movl $0x29, %edi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38e2
movq %rdi, %rcx
movl %esi, %eax
leaq 0x694d(%rip), %rdx      # 0xa1c4
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
leaq 0x6d9a(%rip), %rdi      # 0xa621
movl $0x1, %esi
movl $0xf, %edx
jmp 0x38dc
leaq 0x7187(%rip), %rdi      # 0xaa21
jmp 0x38ac
leaq 0x7177(%rip), %rdi      # 0xaa1a
jmp 0x38bf
leaq 0x7171(%rip), %rdi      # 0xaa1d
movl $0x1, %esi
movl $0x3, %edx
jmp 0x38dc
leaq 0x7158(%rip), %rdi      # 0xaa17
movl $0x1, %esi
movl $0x2, %edx
jmp 0x38dc
leaq 0x7153(%rip), %rdi      # 0xaa25
movl $0x1, %esi
movl $0x4, %edx
popq %rbp
jmp 0x1190
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x396d
leaq 0x7047(%rip), %r15      # 0xa98f
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x79e6
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x3948
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_O1/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 0x7b60
movq 0x10(%r14), %rax
movq $0x0, 0x10(%rbx)
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x3a0d
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x3a1b
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3a32
movl %eax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3a64
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x3a72
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x7b60
movq 0x10(%rbx), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %r15
cmpq $0x3, %r14
jne 0x3acf
leaq 0x6f81(%rip), %rsi      # 0xaa1d
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
je 0x3b51
cmpq $0x3, %r14
jne 0x3acf
leaq 0x6f65(%rip), %rsi      # 0xaa21
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
je 0x3ba2
cmpq $0x4, %r14
je 0x3aff
cmpq $0x2, %r14
jne 0x3bf4
leaq 0x6f34(%rip), %rsi      # 0xaa1a
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
je 0x3b70
cmpq $0x4, %r14
jne 0x3bf4
leaq 0x6f1f(%rip), %rsi      # 0xaa25
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
jne 0x3bf4
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
testq %rcx, %rcx
je 0x3b3b
addq $0x18, %rax
movq %rax, 0x10(%rbx)
decq %rcx
movl $0x5, %eax
jmp 0x3be7
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rbx)
movl $0x5, %eax
jmp 0x3be5
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
testq %rcx, %rcx
je 0x3b8f
addq $0x18, %rax
movq %rax, 0x10(%rbx)
decq %rcx
movl $0x3, %eax
jmp 0x3be7
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
testq %rcx, %rcx
je 0x3bc1
addq $0x18, %rax
movq %rax, 0x10(%rbx)
decq %rcx
movl $0x2, %eax
jmp 0x3be7
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rbx)
movl $0x3, %eax
jmp 0x3be5
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rax
testq %rcx, %rcx
je 0x3bd4
addq $0x18, %rax
movq %rax, 0x10(%rbx)
decq %rcx
movl $0x4, %eax
jmp 0x3be7
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rbx)
movl $0x2, %eax
jmp 0x3be5
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rbx)
movl $0x4, %eax
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rbx), %r12
movq %rbx, %rdi
callq 0x7be6
leaq 0x6e2e(%rip), %rdx      # 0xaa35
leaq 0x6a73(%rip), %r9       # 0xa681
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x70a4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3c58
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x3c66
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rbx)
je 0x3d2d
movq %r15, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x715a
movq %rax, %r15
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x39c6
movq -0x30(%rbp), %rax
movq %rax, 0x10(%r15)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%r15)
movq %r15, %rax
testq %r14, %r14
je 0x3cb9
movq %r15, 0x18(%r14)
movq %r13, %rax
movq %rax, %r13
movq 0x10(%rbx), %rax
movl (%rax), %r14d
cmpl $0x5, %r14d
jne 0x3cdc
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3cfc
addq $0x18, 0x10(%rbx)
decq %rax
jmp 0x3d1d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3d0c
addq $0x18, 0x10(%rbx)
decq %rax
jmp 0x3d1a
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq %rax, 0x10(%rbx)
xorl %eax, %eax
jmp 0x3d1d
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %r13, %r12
movq %rax, 0x8(%rbx)
cmpl $0x5, %r14d
je 0x3c70
jmp 0x3d30
movq %r13, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl $0x16, %esi
callq 0x7b60
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x3d84
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x3d92
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x2, %esi
callq 0x7b60
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x3dbd
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x3dcb
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3e52
movq %rax, (%rbx)
movq %r14, %rdi
movl $0x3, %esi
callq 0x7b60
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x3e01
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x3e0f
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3e84
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3e49
movq 0x10(%r14), %rcx
cmpl $0x17, (%rcx)
jne 0x3e49
addq $0x18, 0x10(%r14)
decq %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3e84
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3ebc
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x3eca
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x3f39
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
cmpl $0x7, (%rax)
je 0x3f3e
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7c46
movq %rax, %r12
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x449c
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, %r14
testq %r15, %r15
je 0x3f2a
movq %r12, 0x30(%r15)
movq %r13, %r14
cmpq $0x0, 0x8(%rbx)
movq %r14, %r13
movq %r12, %r15
jne 0x3ed9
jmp 0x3f41
xorl %r14d, %r14d
jmp 0x3f41
movq %r13, %r14
movq %rbx, %rdi
movl $0x7, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3f68
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x3f76
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
movl $0xc, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3fba
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x3fc8
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x3ff3
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4001
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e52
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4037
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4045
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e84
movq %rax, %rdx
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4095
movq 0x10(%r14), %rcx
addq $0x18, %rcx
decq %rax
cmpl $0x13, -0x18(%rcx)
je 0x4095
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
addq $0x18, %rcx
addq $-0x1, %rax
jb 0x407d
movq %r14, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x40bc
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x40ca
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 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_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x7b60
movq 0x10(%rbx), %rax
movq $0x0, 0x10(%r14)
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x412c
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x413a
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x9, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4165
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4173
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e52
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x41aa
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x41b8
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x7b60
movq 0x10(%rbx), %rax
movq $0x0, 0x10(%r14)
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x420f
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x421d
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x11, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4248
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4256
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x71e2
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x2, (%rax)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x71e2
movq %rax, 0x10(%r15)
movl $0x1, (%rax)
movq 0x10(%r15), %rax
movups (%r14), %xmm0
movups %xmm0, 0x10(%rax)
movq %rbx, %rdi
callq 0x3e52
movq %rax, 0x18(%r15)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x42ca
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x42d8
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x7b60
movq 0x10(%rbx), %rax
movq $0x0, 0x10(%r14)
movups 0x8(%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4335
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4343
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x10, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x436e
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x437c
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x71e2
movq %rax, %r15
movq %rax, 0x10(%r14)
movl $0x6, (%rax)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x71e2
movq %rax, 0x10(%r15)
movl $0x1, (%rax)
movq 0x10(%r15), %rax
movups (%r14), %xmm0
movups %xmm0, 0x10(%rax)
movq %rbx, %rdi
callq 0x3e52
movq %rax, 0x18(%r15)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x43f0
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x43fe
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
movl $0x19, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x443e
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x444c
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e52
movq %rax, %r14
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4482
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x4490
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, %rdi
movl $0x8, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4696
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x46a4
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39c6
movq %rbx, %rdi
movl $0x9, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x46da
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x46e8
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3e52
movq %rax, 0x18(%r14)
movq %rbx, %rdi
movl $0x13, %esi
callq 0x7b60
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x471f
addq $0x18, %rcx
movq %rcx, 0x10(%rbx)
decq %rax
jmp 0x472d
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x7b60
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x4779
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x4787
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x7b60
movq 0x10(%r14), %rax
movups 0x8(%rax), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x7be6
movq %rax, 0x28(%rbx)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
testq %rax, %rax
je 0x47c9
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
decq %rax
jmp 0x47d7
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3c20
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x3a32
movl %eax, 0x18(%rbx)
movq %r14, %rdi
callq 0x3e84
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a12
movq %rsi, %rbx
leaq 0x1(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x49aa
movq %rax, %r14
cmpq $0x0, 0x8(%r15)
je 0x4a6e
movq 0x10(%r15), %rax
leaq 0x7727(%rip), %rcx      # 0xc110
movl (%rcx,%rbx,4), %esi
cmpl %esi, (%rax)
jne 0x4a6e
movq %r15, %rdi
callq 0x7b60
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
testq %rax, %rax
je 0x4a22
addq $0x18, %rcx
movq %rcx, 0x10(%r15)
decq %rax
jmp 0x4a30
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4806
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x49aa
movq %rax, %r12
movq (%r15), %rdi
movl $0x1, %esi
callq 0x71e2
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
leaq 0x76d2(%rip), %rcx      # 0xc130
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b59
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 0x7d6c
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x473a
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 0x4b3d
movq %r15, 0x30(%r13)
movq %r12, %rax
cmpq $0x0, 0x8(%rbx)
movq %rax, %r12
movq %r15, %r13
jne 0x4af9
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_O1/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: print1(_IO_FILE*, S_Expr*)
void print1(FILE *stream, S_Expr *expr)
{
    if (expr == nullptr) {
        print(stream, "()");
    } else {
        switch (expr->type) {
        case S_Expr_Type::Atom: {
            print(stream, expr->atom.name);
        } break;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4b8c
movq %rsi, %r14
movl (%rsi), %eax
testl %eax, %eax
je 0x4bad
cmpl $0x1, %eax
jne 0x4bf6
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rdi
movl $0x1, %esi
jmp 0x4b9d
leaq 0x58ad(%rip), %rdi      # 0xa440
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1190
movl $0x28, %edi
movq %rbx, %rsi
callq 0x1100
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jne 0x4bff
movb $0x1, %r12b
testb $0x1, %r15b
je 0x4bdc
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1100
movl %r15d, %r12d
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4b5c
movq 0x10(%r14), %r14
movl %r12d, %r15d
testq %r14, %r14
jne 0x4bbd
jmp 0x4c23
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f1a(%rip), %rdi      # 0xab20
movl $0x1, %esi
movl $0x3, %edx
movq %rbx, %rcx
callq 0x1190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b5c
movl $0x29, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4cd8
movl $0x2c, %eax
btl %esi, %eax
jae 0x4ca6
leaq 0x6c4f(%rip), %rbx      # 0xb8f3
jmp 0x4cb2
cmpl $0x4, %esi
jne 0x4cdc
leaq 0x5f50(%rip), %rbx      # 0xac02
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x1, (%rax)
movq $0x3, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x4cd1
leaq 0x5e43(%rip), %rdi      # 0xab26
leaq 0x5ed0(%rip), %rsi      # 0xabba
leaq 0x5ee4(%rip), %rcx      # 0xabd5
movl $0x2e, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e4b
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 0x4cfc
movq %rax, %r15
movq (%r14), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r15, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %rax, %rcx
testq %r13, %r13
je 0x4e3a
testq %r12, %r12
je 0x4e5f
cmpl $0x0, (%r12)
jne 0x4e7e
movq %rax, 0x10(%r12)
movq %r13, %rcx
movq 0x18(%rbx), %rbx
movq %rax, %r12
movq %rcx, %r13
testq %rbx, %rbx
jne 0x4de4
jmp 0x4e4d
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5da6(%rip), %rdi      # 0xac0c
leaq 0x5d4d(%rip), %rsi      # 0xabba
leaq 0x5d9d(%rip), %rcx      # 0xac11
movl $0x56, %edx
callq 0x1090
leaq 0x5dc1(%rip), %rdi      # 0xac46
leaq 0x5d2e(%rip), %rsi      # 0xabba
leaq 0x5d7e(%rip), %rcx      # 0xac11
movl $0x57, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5116
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x507e
leaq 0x5d3c(%rip), %r13      # 0xadb8
jmp 0x50a0
cmpl $0x5, %eax
ja 0x5154
movl %eax, %eax
leaq 0x514c(%rip), %rcx      # 0xa1dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5d22(%rip), %r13      # 0xadc2
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x9, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
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 0x5b64(%rip), %rdi      # 0xac81
leaq 0x5a96(%rip), %rsi      # 0xabba
leaq 0x5ba4(%rip), %rcx      # 0xaccf
movl $0x7d, %edx
callq 0x1090
leaq 0x5c1d(%rip), %rdi      # 0xad59
leaq 0x5a77(%rip), %rsi      # 0xabba
leaq 0x5b85(%rip), %rcx      # 0xaccf
movl $0x83, %edx
callq 0x1090
leaq 0x5c9c(%rip), %rdi      # 0xadf7
leaq 0x5a58(%rip), %rsi      # 0xabba
leaq 0x5b66(%rip), %rcx      # 0xaccf
movl $0x8f, %edx
callq 0x1090
leaq 0x5b82(%rip), %rdi      # 0xacfc
leaq 0x5a39(%rip), %rsi      # 0xabba
leaq 0x5b47(%rip), %rcx      # 0xaccf
movl $0x80, %edx
callq 0x1090
leaq 0x5c33(%rip), %rdi      # 0xadcc
leaq 0x5a1a(%rip), %rsi      # 0xabba
leaq 0x5b28(%rip), %rcx      # 0xaccf
movl $0x8b, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_expression(Expression*)
S_Expr *Wat_Compiler::compile_expression(Expression *expression)
{
    switch (expression->kind) {
    case Expression_Kind::Type_Cast:
        return compile_type_cast(expression->type_cast);
    case Expression_Kind::Number_Literal:
        return compile_number_literal(expression->number_literal);
    case Expression_Kind::Bool_Literal:
        return compile_bool_literal(expression->bool_literal);
    case Expression_Kind::Variable:
        return compile_variable(expression->variable);
    case Expression_Kind::Plus:
        return compile_plus(expression->binary_op);
    case Expression_Kind::Multiply:
        return compile_multiply(expression->binary_op);
    case Expression_Kind::Greater:
        return compile_greater(expression->binary_op);
    case Expression_Kind::Rem:
        return compile_rem(expression->binary_op);
    case Expression_Kind::Minus:
        return compile_minus(expression->binary_op);
    case Expression_Kind::And:
        return compile_and(expression->binary_op);
    case Expression_Kind::Less_Equals:
        return compile_less_equals(expression->binary_op);
    case Expression_Kind::Equals:
        return compile_equals(expression->binary_op);
    }

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

// Assembly:
movl (%rsi), %eax
cmpq $0xb, %rax
ja 0x527d
leaq 0x502f(%rip), %rcx      # 0xa1f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsi), %rsi
jmp 0x4ef8
movl 0x10(%rsi), %esi
jmp 0x4f54
movl 0x10(%rsi), %eax
movq 0x18(%rsi), %rdx
movl %eax, %esi
jmp 0x5ca2
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x5408
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x5570
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x59a8
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x504a
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4fb2
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x56d8
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x52a0
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x5840
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x5b10
pushq %rbp
movq %rsp, %rbp
leaq 0x5b6f(%rip), %rdi      # 0xadf7
leaq 0x592b(%rip), %rsi      # 0xabba
leaq 0x6661(%rip), %rcx      # 0xb8f7
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_minus(Binary_Op)
S_Expr *Wat_Compiler::compile_minus(Binary_Op minus)
{
    assert(minus.lhs->type == minus.rhs->type && "Type Checking step didn't work correctly.");

    switch (minus.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no minus operation defined for Type::U0.");
        break;
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no minus operation defined for Type::Bool.");
        break;
    case Type::U8:
    case Type::U32:
        return list(atom("i32.sub"_sv), compile_expression(minus.lhs), compile_expression(minus.rhs));
    case Type::U64:
        return list(atom("i64.sub"_sv), compile_expression(minus.lhs), compile_expression(minus.rhs));
    case Type::Unchecked:
        assert(0 && "Type checking step didn't work correctly");
        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 0x536c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x52d4
leaq 0x5c88(%rip), %r13      # 0xaf5a
jmp 0x52f6
cmpl $0x5, %eax
ja 0x53aa
movl %eax, %eax
leaq 0x4f3e(%rip), %rcx      # 0xa224
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c6c(%rip), %r13      # 0xaf62
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
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 0x5a9e(%rip), %rdi      # 0xae11
leaq 0x5840(%rip), %rsi      # 0xabba
leaq 0x5ae2(%rip), %rcx      # 0xae63
movl $0x95, %edx
callq 0x1090
leaq 0x5b63(%rip), %rdi      # 0xaef5
leaq 0x5821(%rip), %rsi      # 0xabba
leaq 0x5ac3(%rip), %rcx      # 0xae63
movl $0x9c, %edx
callq 0x1090
leaq 0x5a46(%rip), %rdi      # 0xadf7
leaq 0x5802(%rip), %rsi      # 0xabba
leaq 0x5aa4(%rip), %rcx      # 0xae63
movl $0xa8, %edx
callq 0x1090
leaq 0x5ac2(%rip), %rdi      # 0xae92
leaq 0x57e3(%rip), %rsi      # 0xabba
leaq 0x5a85(%rip), %rcx      # 0xae63
movl $0x99, %edx
callq 0x1090
leaq 0x5b7b(%rip), %rdi      # 0xaf6a
leaq 0x57c4(%rip), %rsi      # 0xabba
leaq 0x5a66(%rip), %rcx      # 0xae63
movl $0xa4, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_multiply(Binary_Op)
S_Expr *Wat_Compiler::compile_multiply(Binary_Op multiply)
{
    assert(multiply.lhs->type == multiply.rhs->type && "Type Checking step didn't work correctly.");

    switch (multiply.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no multiply operation defined for Type::U0.");
        break;
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no multiply operation defined for Type::Bool.");
        break;
    case Type::U8:
    case Type::U32:
        return list(atom("i32.mul"_sv), compile_expression(multiply.lhs), compile_expression(multiply.rhs));
    case Type::U64:
        return list(atom("i64.mul"_sv), compile_expression(multiply.lhs), compile_expression(multiply.rhs));
    case Type::Unchecked:
        assert(0 && "Type checking step didn't work correctly");
        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 0x54d4
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x543c
leaq 0x5cb8(%rip), %r13      # 0xb0f2
jmp 0x545e
cmpl $0x5, %eax
ja 0x5512
movl %eax, %eax
leaq 0x4dee(%rip), %rcx      # 0xa23c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c9c(%rip), %r13      # 0xb0fa
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
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 0x5abf(%rip), %rdi      # 0xaf9a
leaq 0x56d8(%rip), %rsi      # 0xabba
leaq 0x5b09(%rip), %rcx      # 0xaff2
movl $0xae, %edx
callq 0x1090
leaq 0x5b90(%rip), %rdi      # 0xb08a
leaq 0x56b9(%rip), %rsi      # 0xabba
leaq 0x5aea(%rip), %rcx      # 0xaff2
movl $0xb5, %edx
callq 0x1090
leaq 0x58de(%rip), %rdi      # 0xadf7
leaq 0x569a(%rip), %rsi      # 0xabba
leaq 0x5acb(%rip), %rcx      # 0xaff2
movl $0xc1, %edx
callq 0x1090
leaq 0x5aec(%rip), %rdi      # 0xb024
leaq 0x567b(%rip), %rsi      # 0xabba
leaq 0x5aac(%rip), %rcx      # 0xaff2
movl $0xb2, %edx
callq 0x1090
leaq 0x5a13(%rip), %rdi      # 0xaf6a
leaq 0x565c(%rip), %rsi      # 0xabba
leaq 0x5a8d(%rip), %rcx      # 0xaff2
movl $0xbd, %edx
callq 0x1090
nop