LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5059
leaq 0x4267(%rip), %rcx      # 0x9208
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsi), %rsi
jmp 0x4cd4
movl 0x10(%rsi), %esi
jmp 0x4d30
movl 0x10(%rsi), %eax
movq 0x18(%rsi), %rdx
movl %eax, %esi
jmp 0x5a7e
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x51e4
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x534c
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x5784
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4e26
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x4d8e
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x54b4
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x507c
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x561c
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
jmp 0x58ec
pushq %rbp
movq %rsp, %rbp
leaq 0x4db3(%rip), %rdi      # 0x9e17
leaq 0x4b6f(%rip), %rsi      # 0x9bda
leaq 0x58a5(%rip), %rcx      # 0xa917
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5148
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x50b0
leaq 0x4ecc(%rip), %r13      # 0x9f7a
jmp 0x50d2
cmpl $0x5, %eax
ja 0x5186
movl %eax, %eax
leaq 0x4176(%rip), %rcx      # 0x9238
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4eb0(%rip), %r13      # 0x9f82
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ce2(%rip), %rdi      # 0x9e31
leaq 0x4a84(%rip), %rsi      # 0x9bda
leaq 0x4d26(%rip), %rcx      # 0x9e83
movl $0x95, %edx
callq 0x1090
leaq 0x4da7(%rip), %rdi      # 0x9f15
leaq 0x4a65(%rip), %rsi      # 0x9bda
leaq 0x4d07(%rip), %rcx      # 0x9e83
movl $0x9c, %edx
callq 0x1090
leaq 0x4c8a(%rip), %rdi      # 0x9e17
leaq 0x4a46(%rip), %rsi      # 0x9bda
leaq 0x4ce8(%rip), %rcx      # 0x9e83
movl $0xa8, %edx
callq 0x1090
leaq 0x4d06(%rip), %rdi      # 0x9eb2
leaq 0x4a27(%rip), %rsi      # 0x9bda
leaq 0x4cc9(%rip), %rcx      # 0x9e83
movl $0x99, %edx
callq 0x1090
leaq 0x4dbf(%rip), %rdi      # 0x9f8a
leaq 0x4a08(%rip), %rsi      # 0x9bda
leaq 0x4caa(%rip), %rcx      # 0x9e83
movl $0xa4, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x52b0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5218
leaq 0x4efc(%rip), %r13      # 0xa112
jmp 0x523a
cmpl $0x5, %eax
ja 0x52ee
movl %eax, %eax
leaq 0x4026(%rip), %rcx      # 0x9250
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ee0(%rip), %r13      # 0xa11a
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d03(%rip), %rdi      # 0x9fba
leaq 0x491c(%rip), %rsi      # 0x9bda
leaq 0x4d4d(%rip), %rcx      # 0xa012
movl $0xae, %edx
callq 0x1090
leaq 0x4dd4(%rip), %rdi      # 0xa0aa
leaq 0x48fd(%rip), %rsi      # 0x9bda
leaq 0x4d2e(%rip), %rcx      # 0xa012
movl $0xb5, %edx
callq 0x1090
leaq 0x4b22(%rip), %rdi      # 0x9e17
leaq 0x48de(%rip), %rsi      # 0x9bda
leaq 0x4d0f(%rip), %rcx      # 0xa012
movl $0xc1, %edx
callq 0x1090
leaq 0x4d30(%rip), %rdi      # 0xa044
leaq 0x48bf(%rip), %rsi      # 0x9bda
leaq 0x4cf0(%rip), %rcx      # 0xa012
movl $0xb2, %edx
callq 0x1090
leaq 0x4c57(%rip), %rdi      # 0x9f8a
leaq 0x48a0(%rip), %rsi      # 0x9bda
leaq 0x4cd1(%rip), %rcx      # 0xa012
movl $0xbd, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_plus(Binary_Op)
S_Expr *Wat_Compiler::compile_plus(Binary_Op plus)
{
    assert(plus.lhs->type == plus.rhs->type && "Type Checking step didn't work correctly.");

    switch (plus.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no plus operation defined for Type::U0");
        break;
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no plus operation defined for Type::Bool");
        break;
    case Type::U8:
    case Type::U32:
        return list(atom("i32.add"_sv), compile_expression(plus.lhs), compile_expression(plus.rhs));
    case Type::U64:
        return list(atom("i64.add"_sv), compile_expression(plus.lhs), compile_expression(plus.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 0x5418
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5380
leaq 0x4ee6(%rip), %r13      # 0xa264
jmp 0x53a2
cmpl $0x5, %eax
ja 0x5456
movl %eax, %eax
leaq 0x3ed6(%rip), %rcx      # 0x9268
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4eca(%rip), %r13      # 0xa26c
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d03(%rip), %rdi      # 0xa122
leaq 0x47b4(%rip), %rsi      # 0x9bda
leaq 0x4d45(%rip), %rcx      # 0xa172
movl $0xc7, %edx
callq 0x1090
leaq 0x4dc3(%rip), %rdi      # 0xa201
leaq 0x4795(%rip), %rsi      # 0x9bda
leaq 0x4d26(%rip), %rcx      # 0xa172
movl $0xce, %edx
callq 0x1090
leaq 0x49ba(%rip), %rdi      # 0x9e17
leaq 0x4776(%rip), %rsi      # 0x9bda
leaq 0x4d07(%rip), %rcx      # 0xa172
movl $0xda, %edx
callq 0x1090
leaq 0x4d24(%rip), %rdi      # 0xa1a0
leaq 0x4757(%rip), %rsi      # 0x9bda
leaq 0x4ce8(%rip), %rcx      # 0xa172
movl $0xcb, %edx
callq 0x1090
leaq 0x4aef(%rip), %rdi      # 0x9f8a
leaq 0x4738(%rip), %rsi      # 0x9bda
leaq 0x4cc9(%rip), %rcx      # 0xa172
movl $0xd6, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_less_equals(Binary_Op)
S_Expr *Wat_Compiler::compile_less_equals(Binary_Op less_equals)
{
    assert(less_equals.lhs->type == less_equals.rhs->type && "Type Checking step didn't work correctly.");

    switch (less_equals.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no less_equals operation defined for Type::U0");
        break;
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no less_equals operation defined for Type::Bool");
        break;
    case Type::U8:
        return list(atom("i32.le_u"_sv), compile_expression(less_equals.lhs), compile_expression(less_equals.rhs));
    case Type::U32:
        return list(atom("i32.le_u"_sv), compile_expression(less_equals.lhs), compile_expression(less_equals.rhs));
    case Type::U64:
        return list(atom("i64.le_u"_sv), compile_expression(less_equals.lhs), compile_expression(less_equals.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 0x5580
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x54e8
leaq 0x4ef3(%rip), %r13      # 0xa3d9
jmp 0x550a
cmpl $0x5, %eax
ja 0x55be
movl %eax, %eax
leaq 0x3d86(%rip), %rcx      # 0x9280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ed8(%rip), %r13      # 0xa3e2
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x8, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4ced(%rip), %rdi      # 0xa274
leaq 0x464c(%rip), %rsi      # 0x9bda
leaq 0x4d3d(%rip), %rcx      # 0xa2d2
movl $0xe0, %edx
callq 0x1090
leaq 0x4dc9(%rip), %rdi      # 0xa36f
leaq 0x462d(%rip), %rsi      # 0x9bda
leaq 0x4d1e(%rip), %rcx      # 0xa2d2
movl $0xe7, %edx
callq 0x1090
leaq 0x4852(%rip), %rdi      # 0x9e17
leaq 0x460e(%rip), %rsi      # 0x9bda
leaq 0x4cff(%rip), %rcx      # 0xa2d2
movl $0xf4, %edx
callq 0x1090
leaq 0x4d23(%rip), %rdi      # 0xa307
leaq 0x45ef(%rip), %rsi      # 0x9bda
leaq 0x4ce0(%rip), %rcx      # 0xa2d2
movl $0xe4, %edx
callq 0x1090
leaq 0x4987(%rip), %rdi      # 0x9f8a
leaq 0x45d0(%rip), %rsi      # 0x9bda
leaq 0x4cc1(%rip), %rcx      # 0xa2d2
movl $0xf0, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_equals(Binary_Op)
S_Expr *Wat_Compiler::compile_equals(Binary_Op equals)
{
    assert(equals.lhs->type == equals.rhs->type && "Type Checking step didn't work correctly.");

    switch (equals.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no equals operation defined for Type::U0");
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no equals operation defined for Type::Bool");
    case Type::U8:
        return list(atom("i32.eq"_sv), compile_expression(equals.lhs), compile_expression(equals.rhs));
    case Type::U32:
        return list(atom("i32.eq"_sv), compile_expression(equals.lhs), compile_expression(equals.rhs));
    case Type::U64:
        return list(atom("i64.eq"_sv), compile_expression(equals.lhs), compile_expression(equals.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 0x56e8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5650
leaq 0x4ee9(%rip), %r13      # 0xa537
jmp 0x5672
cmpl $0x5, %eax
ja 0x5726
movl %eax, %eax
leaq 0x3c36(%rip), %rcx      # 0x9298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ecc(%rip), %r13      # 0xa53e
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x6, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cfc(%rip), %rdi      # 0xa3eb
leaq 0x44e4(%rip), %rsi      # 0x9bda
leaq 0x4d42(%rip), %rcx      # 0xa43f
movl $0xfa, %edx
callq 0x1090
leaq 0x4dc4(%rip), %rdi      # 0xa4d2
leaq 0x44c5(%rip), %rsi      # 0x9bda
leaq 0x4d23(%rip), %rcx      # 0xa43f
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq 0x46ea(%rip), %rdi      # 0x9e17
leaq 0x44a6(%rip), %rsi      # 0x9bda
leaq 0x4d04(%rip), %rcx      # 0xa43f
movl $0x10c, %edx            # imm = 0x10C
callq 0x1090
leaq 0x4d23(%rip), %rdi      # 0xa46f
leaq 0x4487(%rip), %rsi      # 0x9bda
leaq 0x4ce5(%rip), %rcx      # 0xa43f
movl $0xfe, %edx
callq 0x1090
leaq 0x481f(%rip), %rdi      # 0x9f8a
leaq 0x4468(%rip), %rsi      # 0x9bda
leaq 0x4cc6(%rip), %rcx      # 0xa43f
movl $0x108, %edx            # imm = 0x108
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_greater(Binary_Op)
S_Expr *Wat_Compiler::compile_greater(Binary_Op greater)
{
    assert(greater.lhs->type == greater.rhs->type && "Type Checking step didn't work correctly.");

    switch (greater.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no greater operation defined for Type::U0");
    case Type::Bool:
        assert(0 && "Type Checking step didn't work correctly. There is no greater operation defined for Type::Bool");
    case Type::U8:
        return list(atom("i32.gt_u"_sv), compile_expression(greater.lhs), compile_expression(greater.rhs));
    case Type::U32:
        return list(atom("i32.gt_u"_sv), compile_expression(greater.lhs), compile_expression(greater.rhs));
    case Type::U64:
        return list(atom("i64.gt_u"_sv), compile_expression(greater.lhs), compile_expression(greater.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 0x5850
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x57b8
leaq 0x4ee0(%rip), %r13      # 0xa696
jmp 0x57da
cmpl $0x5, %eax
ja 0x588e
movl %eax, %eax
leaq 0x3ae6(%rip), %rcx      # 0x92b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ec5(%rip), %r13      # 0xa69f
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, (%rax)
movq $0x8, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f8e
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8e
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4cee(%rip), %rdi      # 0xa545
leaq 0x437c(%rip), %rsi      # 0x9bda
leaq 0x4d36(%rip), %rcx      # 0xa59b
movl $0x112, %edx            # imm = 0x112
callq 0x1090
leaq 0x4dba(%rip), %rdi      # 0xa630
leaq 0x435d(%rip), %rsi      # 0x9bda
leaq 0x4d17(%rip), %rcx      # 0xa59b
movl $0x118, %edx            # imm = 0x118
callq 0x1090
leaq 0x4582(%rip), %rdi      # 0x9e17
leaq 0x433e(%rip), %rsi      # 0x9bda
leaq 0x4cf8(%rip), %rcx      # 0xa59b
movl $0x124, %edx            # imm = 0x124
callq 0x1090
leaq 0x4d18(%rip), %rdi      # 0xa5cc
leaq 0x431f(%rip), %rsi      # 0x9bda
leaq 0x4cd9(%rip), %rcx      # 0xa59b
movl $0x116, %edx            # imm = 0x116
callq 0x1090
leaq 0x46b7(%rip), %rdi      # 0x9f8a
leaq 0x4300(%rip), %rsi      # 0x9bda
leaq 0x4cba(%rip), %rcx      # 0xa59b
movl $0x120, %edx            # imm = 0x120
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_block(Block*)
S_Expr *Wat_Compiler::compile_block(Block *block)
{
    S_Expr *result = nullptr;

    while (block) {
        result = append(result, list(compile_statement(block->statement)));
        block = block->next;

    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rsi, %rsi
je 0x6394
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5d10
movq %rax, %r12
movq (%r14), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7d14
movq %rax, %r15
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x6335
jmp 0x6397
xorl %r15d, %r15d
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_func_def(Func_Def)
S_Expr *Wat_Compiler::compile_func_def(Func_Def func_def)
{
    return append(
        list(atom("func"_sv),
             atom(concat("$"_sv, func_def.name)),
             list(atom("export"_sv), atom(concat("\""_sv, func_def.name, "\""_sv)))),
        compile_args_list(func_def.args_list),
        list(compile_return_type(func_def.return_type)),
        compile_func_body(func_def.body));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, -0x38(%rbp)
movl $0x1, %ecx
movl %ecx, (%rax)
movq $0x4, 0x8(%rax)
leaq 0x3362(%rip), %rcx      # 0x993f
movq %rcx, 0x10(%rax)
movq 0x10(%rbp), %r14
movq 0x18(%rbp), %r8
movq %r8, -0x30(%rbp)
leaq 0x3550(%rip), %rdx      # 0x9b44
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x7b54
movq %rax, %r12
movq %rdx, %r13
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r15
movl $0x1, %eax
movl %eax, (%r15)
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r12
movl $0x1, %eax
movl %eax, (%r12)
movq $0x6, 0x8(%r12)
leaq 0x43ac(%rip), %rax      # 0xa9ff
movq %rax, 0x10(%r12)
movq $0x1, -0x48(%rbp)
leaq 0x334e(%rip), %rdx      # 0x99b5
movq %rdx, -0x40(%rbp)
movups -0x48(%rbp), %xmm0
movups %xmm0, (%rsp)
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rcx
movq -0x30(%rbp), %r8
callq 0x7e32
movq %rax, %r13
movq %rdx, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x1, %ecx
movl %ecx, (%rax)
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7bbe
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r15
xorl %eax, %eax
movl %eax, (%r15)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r15)
movq %r14, 0x10(%r15)
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b9e
movq %rax, %r14
movl 0x28(%rbp), %esi
movq %rbx, %rdi
callq 0x4c7a
movq %rax, %r12
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r13
xorl %eax, %eax
movl %eax, (%r13)
movq %r12, 0x8(%r13)
movq $0x0, 0x10(%r13)
movq 0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x63a8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rax, %r8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7dd0
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_module(Module)
S_Expr *Wat_Compiler::compile_module(Module module)
{
    S_Expr *result = nullptr;

    Top_Level_Def *top_level_def = module.top_level_defs;
    while (top_level_def) {
        result = append(result, list(compile_func_def(top_level_def->func_def)));
        top_level_def = top_level_def->next;
    }

    return cons(atom("module"_sv), result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x67d4
movq %rsi, %r15
xorl %ebx, %ebx
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x65a2
movq %rax, %r12
movq (%r14), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7d14
movq %rax, %rbx
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x6772
jmp 0x67d6
xorl %ebx, %ebx
movq (%r14), %rdi
movl $0x1, %esi
callq 0x8296
movq %rax, %r15
movl $0x1, (%rax)
movq $0x6, 0x8(%rax)
leaq 0x420b(%rip), %rax      # 0xaa06
movq %rax, 0x10(%r15)
movq (%r14), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_reporter.cpp
// Function: Reporter::offset_to_location(unsigned long) const
Reporter::Location Reporter::offset_to_location(size_t offset) const
{
    String_View input0 = input;
    for (size_t line_number = 1; input0.count > 0; ++line_number) {
        String_View line = input0.chop_by_delim('\n');

        if (offset <= line.count) {
            return {line_number, offset + 1};
        }

        offset -= line.count + 1;
    }

    assert(0 && "I'm not sure when exactly this could happen. Please investigate when triggered.");
    return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movups (%rdi), %xmm0
movaps %xmm0, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x68a6
movq %rsi, %rbx
movl $0x1, %r14d
leaq -0x30(%rbp), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x7eac
cmpq %rax, %rbx
jbe 0x68c5
notq %rax
addq %rax, %rbx
incq %r14
cmpq $0x0, -0x30(%rbp)
jne 0x6884
leaq 0x41cd(%rip), %rdi      # 0xaa7a
leaq 0x4178(%rip), %rsi      # 0xaa2c
leaq 0x4216(%rip), %rcx      # 0xaad1
movl $0x16, %edx
callq 0x1090
incq %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_main.cpp
// Function: target_by_name(aids::String_View)
Maybe<Target> target_by_name(String_View name)
{
    if (name == "wat"_sv)    return {true, Target::Wat};
    if (name == "ast"_sv)    return {true, Target::Ast};
    if (name == "tokens"_sv) return {true, Target::Tokens};
    return {};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x6, %rdi
je 0x6968
cmpq $0x3, %rdi
jne 0x6962
movzwl (%rsi), %ecx
xorl $0x6177, %ecx           # imm = 0x6177
movzbl 0x2(%rsi), %edx
xorl $0x74, %edx
movl $0x1, %eax
orw %cx, %dx
je 0x6964
movzwl (%rsi), %ecx
xorl $0x7361, %ecx           # imm = 0x7361
movzbl 0x2(%rsi), %edx
xorl $0x74, %edx
orw %cx, %dx
je 0x698c
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x6987
movl $0x656b6f74, %ecx       # imm = 0x656B6F74
xorl (%rsi), %ecx
movzwl 0x4(%rsi), %edx
xorl $0x736e, %edx           # imm = 0x736E
xorl %eax, %eax
orl %ecx, %edx
sete %al
movq %rax, %rcx
shlq $0x21, %rcx
orq %rcx, %rax
popq %rbp
retq
movabsq $0x100000000, %rcx      # imm = 0x100000000
jmp 0x6987
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_main.cpp
// Function: usage(_IO_FILE*)
void usage(FILE *stream)
{
    println(stream, "Usage: ./wcc [OPTIONS] <input.wc>");
    println(stream, "OPTIONS:");
    println(stream, "    --target|-t <target>     Generate code for a specific target.");
    println(stream, "                             Available targets: wat, ast, tokens.");
    println(stream, "                             Default target: wat.");
    println(stream, "    --help|-h                Print this help to stdout and exit with 0 exit code.");
    // TODO: output to a specific file is not supported (flag -o)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4172(%rip), %rsi      # 0xab1a
callq 0x7f14
leaq 0x4188(%rip), %rsi      # 0xab3c
movq %rbx, %rdi
callq 0x7f14
leaq 0x4182(%rip), %rsi      # 0xab45
movq %rbx, %rdi
callq 0x7f14
leaq 0x41b5(%rip), %rsi      # 0xab87
movq %rbx, %rdi
callq 0x7f14
leaq 0x41e8(%rip), %rsi      # 0xabc9
movq %rbx, %rdi
callq 0x7f14
leaq 0x420b(%rip), %rsi      # 0xabfb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7f14
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./././wcc_memory.hpp
// Function: Type_Checker::Scope* Linear_Memory::alloc<Type_Checker::Scope>(unsigned long)
T *alloc(size_t n = 1)
    {
        assert(n > 0);
        assert(size + sizeof(T) * n <= capacity);
        T *result = top<T>();
        memset(result, 0, sizeof(T) * n);
        size += sizeof(T) * n;
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x6e7f
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
shlq $0x4, %rbx
leaq (%r15,%rbx), %rax
cmpq (%rdi), %rax
ja 0x6e9e
addq 0x10(%r14), %r15
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1080
addq %rbx, 0x8(%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f6c(%rip), %rdi      # 0xadf2
leaq 0x3f6b(%rip), %rsi      # 0xadf8
leaq 0x4038(%rip), %rcx      # 0xaecc
movl $0x13, %edx
callq 0x1090
leaq 0x3f99(%rip), %rdi      # 0xae3e
leaq 0x3f4c(%rip), %rsi      # 0xadf8
leaq 0x4019(%rip), %rcx      # 0xaecc
movl $0x14, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./aids.hpp
// Function: aids::String_View::trim_begin() const
[[nodiscard]]
        String_View trim_begin(void) const
        {
            String_View view = *this;

            while (view.count != 0 && isspace(*view.data)) {
                view.data  += 1;
                view.count -= 1;
            }
            return view;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %rbx
testq %r14, %r14
je 0x7032
leaq (%rbx,%r14), %r15
movsbl (%rbx), %edi
callq 0x1050
testl %eax, %eax
je 0x7035
incq %rbx
decq %r14
jne 0x7016
xorl %r14d, %r14d
movq %r15, %rbx
jmp 0x7035
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./aids.hpp
// Function: aids::Dynamic_Array<Token>::push(Token)
void push(T item)
        {
            while (size + 1 > capacity) {
                expand_capacity();
            }

            memcpy(data + size, &item, sizeof(T));
            size += 1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq 0x10(%rdi), %rax
cmpq %rcx, %rsi
jbe 0x70a2
movl $0x100, %r15d           # imm = 0x100
addq %rcx, %rcx
testq %rax, %rax
cmoveq %r15, %rcx
movq %rcx, (%rbx)
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
callq 0x1160
movq %rax, 0x10(%rbx)
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rsi
ja 0x7071
leaq (%rdx,%rdx,2), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rax,%rcx,8)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./aids.hpp
// Function: aids::Maybe<unsigned int> aids::String_View::as_integer<unsigned int>() const
Maybe<Integer> as_integer() const
        {
            Integer sign = 1;
            Integer number = {};
            String_View view = *this;

            if (view.count == 0) {
                return {};
            }

            if (*view.data == '-') {
                sign = -1;
                view.chop(1);
            }

            while (view.count) {
                if (!isdigit(*view.data)) {
                    return {};
                }
                number = number * 10 + (*view.data - '0');
                view.chop(1);
            }

            return { true, number * sign };
        }

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x7aa1
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rsi
movb (%rsi), %dl
xorl %edi, %edi
cmpb $0x2d, %dl
sete %dil
cmpq %rdi, %rcx
je 0x7a8c
negq %rdi
xorl %eax, %eax
cmpb $0x2d, %dl
sete %al
addq %rax, %rsi
addq %rdi, %rcx
negq %rcx
xorl %edi, %edi
xorl %r8d, %r8d
xorl %eax, %eax
movsbl (%rsi,%r8), %r9d
addl $-0x30, %r9d
cmpl $0x9, %r9d
ja 0x7aa5
leal (%rax,%rax,4), %eax
leal (%r9,%rax,2), %eax
incq %r8
movq %rcx, %r9
addq %r8, %r9
jne 0x7a6b
movl %eax, %edi
negl %edi
cmpb $0x2d, %dl
cmovnel %eax, %edi
shlq $0x20, %rdi
movl $0x1, %eax
jmp 0x7aa7
xorl %edi, %edi
jmp 0x7aa8
xorl %eax, %eax
popq %rbp
orq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.hpp
// Function: aids::String_View Wat_Compiler::concat<aids::String_View, aids::String_View>(aids::String_View, aids::String_View)
String_View concat(Strings... s)
    {
        String_Buffer buffer = {};
        buffer.capacity = (s.count + ...) + 1;
        buffer.data = memory->alloc<char>(buffer.capacity);
        sprintln(&buffer, s...);
        return buffer.view();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq -0x40(%rbp), %r13
movq $0x0, 0x10(%r13)
addq %rcx, %rsi
incq %rsi
movq %rsi, (%r13)
movq (%rdi), %rdi
callq 0x831e
movq %rax, 0x8(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x8b17
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.hpp
// Function: Wat_Compiler::atom(unsigned int)
S_Expr *atom(uint32_t number)
    {
        String_Buffer buffer = {};
        buffer.capacity = 16;   // NOTE: 2^32 = 4294967296 so 16 chars should be more than enough
        buffer.data = memory->alloc<char>(16);
        sprint(&buffer, number);
        return atom(buffer.view());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rdi
movl $0x10, %esi
callq 0x831e
movq %rax, %rbx
leaq 0x1789(%rip), %rdx      # 0x93ce
movl $0x10, %esi
movq %rax, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1140
cmpl $0xf, %eax
movl $0xf, %r14d
cmovbl %eax, %r14d
movq (%r15), %rdi
movl $0x1, %esi
callq 0x8296
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./wcc_wat_compiler.hpp
// Function: S_Expr* Wat_Compiler::append<S_Expr*>(S_Expr*, S_Expr*)
S_Expr *append(S_Expr *list1, Rest... rest)
    {
        S_Expr *list2 = append(rest...);

        if (list1 == nullptr) {
            return list2;
        }

        S_Expr *last = list1;

        while (last != nullptr &&
               last->type == S_Expr_Type::Cons &&
               last->cons.tail != nullptr)
        {
            last = last->cons.tail;
        }

        assert(last);
        assert(last->type == S_Expr_Type::Cons);
        assert(last->cons.tail == nullptr);

        last->cons.tail = list2;

        return list1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdx, %rsi
callq 0x8d50
testq %rbx, %rbx
je 0x7d44
movq %rbx, %rdx
cmpl $0x0, (%rdx)
jne 0x7d51
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x7d2d
movq %rax, 0x10(%rcx)
jmp 0x7d47
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f0e(%rip), %rdi      # 0x9c66
leaq 0x3268(%rip), %rsi      # 0xafc7
leaq 0x327c(%rip), %rcx      # 0xafe2
movl $0x65, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/tsoding[P]wcc/src/./aids.hpp
// Function: aids::String_View::chop_by_delim(char)
String_View chop_by_delim(char delim)
        {
            assert(data);

            size_t i = 0;
            while (i < count && data[i] != delim) i++;
            String_View result = {i, data};
            chop(i + 1);

            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x7ef5
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x7ed4
cmpb %sil, (%rdx,%rax)
je 0x7ed4
incq %rax
cmpq %rax, %rcx
jne 0x7ec3
movq %rcx, %rax
leaq 0x1(%rax), %rsi
xorl %r8d, %r8d
movq %rcx, %r9
subq %rsi, %r9
cmovbq %rcx, %rsi
cmovaeq %r9, %r8
addq %rdx, %rsi
movq %rsi, 0x8(%rdi)
movq %r8, (%rdi)
popq %rbp
retq
leaq 0x1a80(%rip), %rdi      # 0x997c
leaq 0x2f87(%rip), %rsi      # 0xae8a
leaq 0x2f8f(%rip), %rcx      # 0xae99
movl $0x106, %edx            # imm = 0x106
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeSite.cpp
// Function: VelSite::computeRhoAndU(double&, double*)
void VelSite::computeRhoAndU(double& rho, double u[2])
{
  rho = 0;

  for (int k=0; k<q; k++)
    {rho += f[k];}

  u[0] = 0;
  u[1] = 0;

  for (int k=0; k<9; k++)
    {
      u[0] += f[k]*e[k][0];
      u[1] += f[k]*e[k][1];
    }
  u[0] /= rho;
  u[1] /= rho;
}

// Assembly:
movq $0x0, (%rsi)
movslq 0x50(%rdi), %rax
testq %rax, %rax
jle 0x2610
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
addsd 0x8(%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rsi)
incq %rcx
cmpq %rcx, %rax
jne 0x25fe
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdx)
xorpd %xmm0, %xmm0
xorl %eax, %eax
leaq 0x3a2b(%rip), %rcx      # 0x6050
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl (%rcx,%rax,8), %xmm2
mulsd 0x8(%rdi,%rax,8), %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, (%rdx)
xorps %xmm2, %xmm2
cvtsi2sdl 0x4(%rcx,%rax,8), %xmm2
mulsd 0x8(%rdi,%rax,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rdx)
incq %rax
cmpq $0x9, %rax
jne 0x2629
divsd (%rsi), %xmm0
movsd %xmm0, (%rdx)
divsd (%rsi), %xmm1
movsd %xmm1, 0x8(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeSite.cpp
// Function: VelSite::collide(double&, double&, double*, double)
void VelSite::collide(double& rho, double& T, double u[2], double omega)
{
  //computeRhoAndU(rho, u);
  double eu, a, F;
  a = (1.-0.5*omega);
  for (int k=0; k<q; k++)
    {
      //Compute the force from Boussinesq approx
      eu = e[k][0]*u[0] + e[k][1]*u[1];
      F = rho*coef_force*T;
      //force = a * w[k] * (3.*(e[k][1]*F-u[1]*F) + 9.*eu*F);
      force =  3.*w[k]*rho*coef_force*T*e[k][1];
      f[k]= f[k]*(1.-omega) +fEq(k,rho,u)*omega + force;	  
      // f[k] *= (1.0-omega);
      // f[k] += omega*fEq(k, rho, u);
    }
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
cmpl $0x0, 0x50(%rdi)
jle 0x282b
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x3889(%rip), %xmm0     # 0x6010
subsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x3907(%rip), %rbp      # 0x60a0
xorl %r13d, %r13d
leaq 0x38ad(%rip), %rax      # 0x6050
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rax,%r13,8), %xmm0
movsd (%rbp), %xmm1
mulsd 0x384e(%rip), %xmm1     # 0x6008
mulsd (%r15), %xmm1
mulsd 0x68(%r12), %xmm1
mulsd (%r14), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x58(%r12)
movsd (%r15), %xmm0
movq (%r12), %rax
movsd 0x8(%r12,%r13,8), %xmm1
mulsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq *(%rax)
mulsd (%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addsd 0x58(%r12), %xmm0
movsd %xmm0, 0x8(%r12,%r13,8)
incq %r13
movslq 0x50(%r12), %rax
addq $0x8, %rbp
cmpq %rax, %r13
jl 0x279c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/LatticeSite.cpp
// Function: ThermalSite::collide(double&, double&, double*, double)
void ThermalSite::collide(double& rho, double& T, double u[2], double omega)
{
  //computeRhoAndU(T);

		for (int k=0; k<q; k++)
		{
			f[k] *= (1.0-omega);
			f[k] += omega*fEq(k, T, u);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
cmpl $0x0, 0x50(%rdi)
jle 0x28b8
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movsd 0x37ae(%rip), %xmm0     # 0x6010
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
movsd 0x8(%r15,%r12,8), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%r15,%r12,8)
movsd (%r14), %xmm0
movq (%r15), %rax
movq %r15, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq *(%rax)
mulsd 0x8(%rsp), %xmm0
addsd 0x8(%r15,%r12,8), %xmm0
movsd %xmm0, 0x8(%r15,%r12,8)
incq %r12
movslq 0x50(%r15), %rax
cmpq %rax, %r12
jl 0x2871
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::TopWall(int const*)
TopWall::TopWall(const int d[2])
{
  nbNodes = d[0];
  nodes = new int*[nbNodes];
  for (int i=0;i<nbNodes;i++)
    {nodes[i] = new int[2];}

  int cc = 0;

  for (int x=0;x<d[0];x++)
    {
      nodes[cc][0] = x; nodes[cc][1] = d[1]-1;
      cc += 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6423(%rip), %rax      # 0x8d08
movq %rax, (%rdi)
movslq (%rsi), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x8(%rdi)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
testq %r15, %r15
jle 0x2950
xorl %r12d, %r12d
movl $0x8, %edi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2916
testl %r15d, %r15d
jle 0x2950
movq 0x10(%r14), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movl %ecx, (%rdx)
movl 0x4(%rbx), %esi
decl %esi
movl %esi, 0x4(%rdx)
incq %rcx
cmpl %ecx, (%rbx)
jg 0x293b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::BoundaryCondition(VelSite**, VelSite**)
void TopWall::BoundaryCondition(VelSite **sites, VelSite **_sites)
{
  int x,y;
  int op[9] = {0, 3, 4, 1, 2, 7, 8, 5, 6};
  for (int i=0;i<nbNodes;i++)
    {
      x = nodes[i][0]; y = nodes[i][1];
      for (int k=0;k<9;k++)
	{
	  _sites[x][y].f[k] = sites[x][y].f[op[k]];
	}
    }
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x29c1
pushq %rbx
movq 0x10(%rdi), %rcx
xorl %edi, %edi
leaq 0x379b(%rip), %r8       # 0x6110
movq (%rcx,%rdi,8), %r9
movslq (%r9), %r11
movslq 0x4(%r9), %r9
movq (%rdx,%r11,8), %r10
movq %r9, %rbx
shlq $0x7, %rbx
leaq (%rbx,%r9,8), %r9
addq %r9, %r10
addq $0x8, %r10
addq (%rsi,%r11,8), %r9
xorl %r11d, %r11d
movslq (%r11,%r8), %rbx
movsd 0x8(%r9,%rbx,8), %xmm0
movsd %xmm0, (%r10,%r11,2)
addq $0x4, %r11
cmpq $0x24, %r11
jne 0x299d
incq %rdi
cmpq %rax, %rdi
jne 0x2975
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::FreeSlipBC(VelSite**, VelSite**)
void TopWall::FreeSlipBC(VelSite **sites, VelSite **_sites)
{
  int x,y;
  
  for (int i=0;i<nbNodes;i++)
    {
      x = nodes[i][0]; y = nodes[i][1];
      _sites[x][y].f[7] = _sites[x][y].f[6];
      _sites[x][y].f[4] = _sites[x][y].f[2];
      _sites[x][y].f[8] = _sites[x][y].f[5];
    }
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x2a11
movq 0x10(%rdi), %rcx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movslq (%rdi), %r8
movslq 0x4(%rdi), %rdi
movq (%rdx,%r8,8), %r8
movq %rdi, %r9
shlq $0x7, %r9
leaq (%r9,%rdi,8), %rdi
movsd 0x18(%r8,%rdi), %xmm0
movsd %xmm0, 0x28(%r8,%rdi)
movups 0x30(%r8,%rdi), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x40(%r8,%rdi)
incq %rsi
cmpq %rsi, %rax
jne 0x29d1
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::HalfWayFreeSlipBC(VelSite**, VelSite**)
void TopWall::HalfWayFreeSlipBC(VelSite **sites, VelSite **_sites)
{
  int x,y;
  int xm, xp;
  
  for (int i=0;i<nbNodes;i++)
    {
      x = nodes[i][0]; y = nodes[i][1];
      xp = (x + 1 + nbNodes)%nbNodes; 
      xm = (x - 1 + nbNodes)%nbNodes; 
      
      _sites[x][y].f[7] = sites[xp][y].f[6];
      _sites[x][y].f[4] = sites[x][y].f[2];
      _sites[x][y].f[8] = sites[xm][y].f[5];
    }
}

// Assembly:
movslq 0x8(%rdi), %r8
testq %r8, %r8
jle 0x2aa5
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq 0x10(%rdi), %r9
leal 0x1(%r8), %r10d
leal -0x1(%r8), %r11d
xorl %ebx, %ebx
movq (%r9,%rbx,8), %rdi
movslq (%rdi), %r14
leal (%r10,%r14), %eax
cltd
movslq 0x4(%rdi), %r15
idivl %r8d
movl %edx, %edi
leal (%r11,%r14), %eax
cltd
idivl %r8d
movslq %edi, %rax
movq (%rsi,%rax,8), %rax
movq %r15, %rdi
shlq $0x7, %rdi
leaq (%rdi,%r15,8), %rdi
movsd 0x38(%rax,%rdi), %xmm0
movq (%rcx,%r14,8), %rax
movsd %xmm0, 0x40(%rax,%rdi)
movq (%rsi,%r14,8), %r14
movsd 0x18(%r14,%rdi), %xmm0
movsd %xmm0, 0x28(%rax,%rdi)
movslq %edx, %rdx
movq (%rsi,%rdx,8), %rdx
movsd 0x30(%rdx,%rdi), %xmm0
movsd %xmm0, 0x48(%rax,%rdi)
incq %rbx
cmpq %rbx, %r8
jne 0x2a35
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: TopWall::TemperatureBC(VelSite**, ThermalSite**, double**, double***)
void TopWall::TemperatureBC(VelSite **velSites, ThermalSite **thermalSites,
				double **T, double ***u)
{
  int c[4][2] = {{1,0}, {0,1}, {-1,0}, {0, -1}};
  int x,y; 
  double Tcold = 0.0;
  double Tinf, rho, ub[2], uinf[2];
  for (int i=0;i<nbNodes;i++)
    {
      double eu;
      x = nodes[i][0]; y = nodes[i][1];

      thermalSites[x][y-1].computeRhoAndU(Tinf);
      velSites[x][y-1].computeRhoAndU(rho, uinf);
      velSites[x][y].computeRhoAndU(rho, ub);
      
      for (int k=0;k<4;k++)
	{
	  eu = c[k][0]*ub[0] + c[k][1]*ub[1];
	  thermalSites[x][y].f[k] = (Tinf/4.)*(1.+2.*eu) + thermalSites[x][y-1].f[k]
	    - thermalSites[x][y-1].fEq(k,Tinf,uinf);
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x10(%rsp)
cmpl $0x0, 0x8(%rdi)
jle 0x2c05
movq %rdx, %rbx
xorl %ecx, %ecx
leaq 0x3681(%rip), %r14      # 0x6150
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rax
movslq (%rax), %r15
movslq 0x4(%rax), %rbp
movq (%rbx,%r15,8), %rax
leaq -0x1(%rbp), %rcx
movq %rcx, (%rsp)
imulq $0x70, %rbp, %r13
leaq (%rax,%r13), %rdi
addq $-0x70, %rdi
movq (%rdi), %rax
leaq 0x28(%rsp), %rsi
callq *0x20(%rax)
movq 0x10(%rsp), %r12
movq (%r12,%r15,8), %rax
movq %rbp, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rbp,8), %rbp
leaq (%rax,%rbp), %rdi
addq $-0x88, %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq *0x8(%rax)
movq (%r12,%r15,8), %rax
leaq (%rax,%rbp), %rdi
movq (%rax,%rbp), %rax
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq *0x8(%rax)
movq (%rbx,%r15,8), %rax
imulq $0x70, (%rsp), %rbp
xorl %r12d, %r12d
xorps %xmm2, %xmm2
cvtsi2sdl (%r14,%r12,8), %xmm2
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%r14,%r12,8), %xmm0
mulsd 0x38(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm2
addsd %xmm0, %xmm2
movsd 0x28(%rsp), %xmm0
movapd %xmm0, %xmm1
mulsd 0x3494(%rip), %xmm1     # 0x6028
addsd %xmm2, %xmm2
addsd 0x3470(%rip), %xmm2     # 0x6010
mulsd %xmm1, %xmm2
leaq (%rax,%rbp), %rdi
leaq (%rax,%r13), %rcx
addsd -0x68(%rcx,%r12,8), %xmm2
movsd %xmm2, (%rsp)
movq (%rax,%rbp), %rax
movl %r12d, %esi
leaq 0x40(%rsp), %rdx
callq *(%rax)
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movq (%rbx,%r15,8), %rax
leaq (%rax,%r13), %rcx
movsd %xmm1, 0x8(%rcx,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x2b5f
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jl 0x2ad4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::BottomWall(int const*)
BottomWall::BottomWall(const int d[2])
{
  nbNodes = d[0];
  nodes = new int*[nbNodes];
  for (int i=0;i<nbNodes;i++)
    {nodes[i] = new int[2];}

  int cc = 0;

  for (int x=0;x<d[0];x++)
    {
      nodes[cc][0] = x; nodes[cc][1] = 0;
      cc += 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60ff(%rip), %rax      # 0x8d28
movq %rax, (%rdi)
movslq (%rsi), %r15
leaq (,%r15,8), %rax
testq %r15, %r15
movl %r15d, 0x8(%rdi)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
testq %r15, %r15
jle 0x2c93
xorl %r12d, %r12d
movl $0x8, %edi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2c5a
testl %r15d, %r15d
jle 0x2c93
movq 0x10(%r14), %rax
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movl %ecx, (%rdx)
movl $0x0, 0x4(%rdx)
incq %rcx
cmpl %ecx, (%rbx)
jg 0x2c7f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop