LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x44f5
cmpl $0x5, %eax
ja 0x4514
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x3cd0(%rip), %rcx      # 0x816c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ac2(%rip), %rdx      # 0x8f6e
jmp 0x44b5
leaq 0x4ac1(%rip), %rdx      # 0x8f76
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4929(%rip), %rdi      # 0x8e25
leaq 0x46cb(%rip), %rsi      # 0x8bce
leaq 0x496d(%rip), %rcx      # 0x8e77
movl $0x95, %edx
callq 0x1090
leaq 0x48f0(%rip), %rdi      # 0x8e0b
leaq 0x46ac(%rip), %rsi      # 0x8bce
leaq 0x494e(%rip), %rcx      # 0x8e77
movl $0xa8, %edx
callq 0x1090
leaq 0x49cf(%rip), %rdi      # 0x8f09
leaq 0x468d(%rip), %rsi      # 0x8bce
leaq 0x492f(%rip), %rcx      # 0x8e77
movl $0x9c, %edx
callq 0x1090
leaq 0x4a25(%rip), %rdi      # 0x8f7e
leaq 0x466e(%rip), %rsi      # 0x8bce
leaq 0x4910(%rip), %rcx      # 0x8e77
movl $0xa4, %edx
callq 0x1090
leaq 0x492e(%rip), %rdi      # 0x8ea6
leaq 0x464f(%rip), %rsi      # 0x8bce
leaq 0x48f1(%rip), %rcx      # 0x8e77
movl $0x99, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x4617
cmpl $0x5, %eax
ja 0x4636
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x3bc6(%rip), %rcx      # 0x8184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4b38(%rip), %rdx      # 0x9106
jmp 0x45d7
leaq 0x4b37(%rip), %rdx      # 0x910e
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4990(%rip), %rdi      # 0x8fae
leaq 0x45a9(%rip), %rsi      # 0x8bce
leaq 0x49da(%rip), %rcx      # 0x9006
movl $0xae, %edx
callq 0x1090
leaq 0x47ce(%rip), %rdi      # 0x8e0b
leaq 0x458a(%rip), %rsi      # 0x8bce
leaq 0x49bb(%rip), %rcx      # 0x9006
movl $0xc1, %edx
callq 0x1090
leaq 0x4a42(%rip), %rdi      # 0x909e
leaq 0x456b(%rip), %rsi      # 0x8bce
leaq 0x499c(%rip), %rcx      # 0x9006
movl $0xb5, %edx
callq 0x1090
leaq 0x4903(%rip), %rdi      # 0x8f7e
leaq 0x454c(%rip), %rsi      # 0x8bce
leaq 0x497d(%rip), %rcx      # 0x9006
movl $0xbd, %edx
callq 0x1090
leaq 0x499e(%rip), %rdi      # 0x9038
leaq 0x452d(%rip), %rsi      # 0x8bce
leaq 0x495e(%rip), %rcx      # 0x9006
movl $0xb2, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x4739
cmpl $0x5, %eax
ja 0x4758
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x3abc(%rip), %rcx      # 0x819c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4b68(%rip), %rdx      # 0x9258
jmp 0x46f9
leaq 0x4b67(%rip), %rdx      # 0x9260
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x49d6(%rip), %rdi      # 0x9116
leaq 0x4487(%rip), %rsi      # 0x8bce
leaq 0x4a18(%rip), %rcx      # 0x9166
movl $0xc7, %edx
callq 0x1090
leaq 0x46ac(%rip), %rdi      # 0x8e0b
leaq 0x4468(%rip), %rsi      # 0x8bce
leaq 0x49f9(%rip), %rcx      # 0x9166
movl $0xda, %edx
callq 0x1090
leaq 0x4a77(%rip), %rdi      # 0x91f5
leaq 0x4449(%rip), %rsi      # 0x8bce
leaq 0x49da(%rip), %rcx      # 0x9166
movl $0xce, %edx
callq 0x1090
leaq 0x47e1(%rip), %rdi      # 0x8f7e
leaq 0x442a(%rip), %rsi      # 0x8bce
leaq 0x49bb(%rip), %rcx      # 0x9166
movl $0xd6, %edx
callq 0x1090
leaq 0x49d8(%rip), %rdi      # 0x9194
leaq 0x440b(%rip), %rsi      # 0x8bce
leaq 0x499c(%rip), %rcx      # 0x9166
movl $0xcb, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x485b
cmpl $0x5, %eax
ja 0x487a
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x39b2(%rip), %rcx      # 0x81b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4bbb(%rip), %rdx      # 0x93cd
jmp 0x481b
leaq 0x4bbb(%rip), %rdx      # 0x93d6
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4a06(%rip), %rdi      # 0x9268
leaq 0x4365(%rip), %rsi      # 0x8bce
leaq 0x4a56(%rip), %rcx      # 0x92c6
movl $0xe0, %edx
callq 0x1090
leaq 0x458a(%rip), %rdi      # 0x8e0b
leaq 0x4346(%rip), %rsi      # 0x8bce
leaq 0x4a37(%rip), %rcx      # 0x92c6
movl $0xf4, %edx
callq 0x1090
leaq 0x4ac3(%rip), %rdi      # 0x9363
leaq 0x4327(%rip), %rsi      # 0x8bce
leaq 0x4a18(%rip), %rcx      # 0x92c6
movl $0xe7, %edx
callq 0x1090
leaq 0x46bf(%rip), %rdi      # 0x8f7e
leaq 0x4308(%rip), %rsi      # 0x8bce
leaq 0x49f9(%rip), %rcx      # 0x92c6
movl $0xf0, %edx
callq 0x1090
leaq 0x4a1d(%rip), %rdi      # 0x92fb
leaq 0x42e9(%rip), %rsi      # 0x8bce
leaq 0x49da(%rip), %rcx      # 0x92c6
movl $0xe4, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x497d
cmpl $0x5, %eax
ja 0x499c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x38a8(%rip), %rcx      # 0x81cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4bf7(%rip), %rdx      # 0x952b
jmp 0x493d
leaq 0x4bf5(%rip), %rdx      # 0x9532
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4a5b(%rip), %rdi      # 0x93df
leaq 0x4243(%rip), %rsi      # 0x8bce
leaq 0x4aa1(%rip), %rcx      # 0x9433
movl $0xfa, %edx
callq 0x1090
leaq 0x4468(%rip), %rdi      # 0x8e0b
leaq 0x4224(%rip), %rsi      # 0x8bce
leaq 0x4a82(%rip), %rcx      # 0x9433
movl $0x10c, %edx            # imm = 0x10C
callq 0x1090
leaq 0x4b04(%rip), %rdi      # 0x94c6
leaq 0x4205(%rip), %rsi      # 0x8bce
leaq 0x4a63(%rip), %rcx      # 0x9433
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq 0x459d(%rip), %rdi      # 0x8f7e
leaq 0x41e6(%rip), %rsi      # 0x8bce
leaq 0x4a44(%rip), %rcx      # 0x9433
movl $0x108, %edx            # imm = 0x108
callq 0x1090
leaq 0x4a63(%rip), %rdi      # 0x9463
leaq 0x41c7(%rip), %rsi      # 0x8bce
leaq 0x4a25(%rip), %rcx      # 0x9433
movl $0xfe, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x4a9f
cmpl $0x5, %eax
ja 0x4abe
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl %eax, %eax
leaq 0x379e(%rip), %rcx      # 0x81e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4c34(%rip), %rdx      # 0x968a
jmp 0x4a5f
leaq 0x4c34(%rip), %rdx      # 0x9693
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4a93(%rip), %rdi      # 0x9539
leaq 0x4121(%rip), %rsi      # 0x8bce
leaq 0x4adb(%rip), %rcx      # 0x958f
movl $0x112, %edx            # imm = 0x112
callq 0x1090
leaq 0x4346(%rip), %rdi      # 0x8e0b
leaq 0x4102(%rip), %rsi      # 0x8bce
leaq 0x4abc(%rip), %rcx      # 0x958f
movl $0x124, %edx            # imm = 0x124
callq 0x1090
leaq 0x4b40(%rip), %rdi      # 0x9624
leaq 0x40e3(%rip), %rsi      # 0x8bce
leaq 0x4a9d(%rip), %rcx      # 0x958f
movl $0x118, %edx            # imm = 0x118
callq 0x1090
leaq 0x447b(%rip), %rdi      # 0x8f7e
leaq 0x40c4(%rip), %rsi      # 0x8bce
leaq 0x4a7e(%rip), %rcx      # 0x958f
movl $0x120, %edx            # imm = 0x120
callq 0x1090
leaq 0x4a9e(%rip), %rdi      # 0x95c0
leaq 0x40a5(%rip), %rsi      # 0x8bce
leaq 0x4a5f(%rip), %rcx      # 0x958f
movl $0x116, %edx            # imm = 0x116
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_and(Binary_Op)
S_Expr *Wat_Compiler::compile_and(Binary_Op andd)
{
    assert(andd.lhs->type == andd.rhs->type && "Type Checking step didn't work correctly.");

    switch (andd.lhs->type) {
    case Type::U0:
        assert(0 && "Type Checking step didn't work correctly. There is no and operation defined for Type::U0");
        break;
    case Type::U8:
        assert(0 && "Type Checking step didn't work correctly. There is no and operation defined for Type::U8");
        break;
    case Type::U32:
        assert(0 && "Type Checking step didn't work correctly. There is no and operation defined for Type::U32");
        break;
    case Type::U64:
        assert(0 && "Type Checking step didn't work correctly. There is no and operation defined for Type::U64");
        break;
    case Type::Bool:
        return list(atom("i32.and"_sv), compile_expression(andd.lhs), compile_expression(andd.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 %r12
pushq %rbx
movl 0x4(%rsi), %eax
cmpl 0x4(%rdx), %eax
jne 0x4bb1
cmpl $0x5, %eax
ja 0x4bd0
movl %eax, %eax
leaq 0x36a1(%rip), %rcx      # 0x81fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4d27(%rip), %rdx      # 0x989b
pushq $0x7
popq %rsi
callq 0x6716
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4380
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67aa
leaq 0x4ae4(%rip), %rdi      # 0x969c
leaq 0x400f(%rip), %rsi      # 0x8bce
leaq 0x4b26(%rip), %rcx      # 0x96ec
movl $0x12a, %edx            # imm = 0x12A
callq 0x1090
leaq 0x4234(%rip), %rdi      # 0x8e0b
leaq 0x3ff0(%rip), %rsi      # 0x8bce
leaq 0x4b07(%rip), %rcx      # 0x96ec
movl $0x140, %edx            # imm = 0x140
callq 0x1090
leaq 0x4c44(%rip), %rdi      # 0x983a
leaq 0x3fd1(%rip), %rsi      # 0x8bce
leaq 0x4ae8(%rip), %rcx      # 0x96ec
movl $0x137, %edx            # imm = 0x137
callq 0x1090
leaq 0x4b64(%rip), %rdi      # 0x9779
leaq 0x3fb2(%rip), %rsi      # 0x8bce
leaq 0x4ac9(%rip), %rcx      # 0x96ec
movl $0x131, %edx            # imm = 0x131
callq 0x1090
leaq 0x4ba5(%rip), %rdi      # 0x97d9
leaq 0x3f93(%rip), %rsi      # 0x8bce
leaq 0x4aaa(%rip), %rcx      # 0x96ec
movl $0x134, %edx            # imm = 0x134
callq 0x1090
leaq 0x432b(%rip), %rdi      # 0x8f7e
leaq 0x3f74(%rip), %rsi      # 0x8bce
leaq 0x4a8b(%rip), %rcx      # 0x96ec
movl $0x13c, %edx            # imm = 0x13C
callq 0x1090
leaq 0x4aa7(%rip), %rdi      # 0x9719
leaq 0x3f55(%rip), %rsi      # 0x8bce
leaq 0x4a6c(%rip), %rcx      # 0x96ec
movl $0x12e, %edx            # imm = 0x12E
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x534c
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 0x4eec
movq %r14, %rdi
movq %rax, %rsi
callq 0x6920
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x68c6
movq %rax, %r15
movq 0x30(%rbx), %rbx
jmp 0x5304
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_func_body(Block*)
S_Expr *Wat_Compiler::compile_func_body(Block *block)
{
    S_Expr *local_var_def_section = nullptr;
    S_Expr *local_var_def_init = nullptr;

    while (block && block->statement.kind == Statement_Kind::Local_Var_Def) {
        auto var_ident = wat_ident(block->statement.local_var_def.def.name);

        local_var_def_section = append(
            local_var_def_section,
            list(list(atom("local"_sv),
                      var_ident,
                      wat_name_of_type(block->statement.local_var_def.def.type))));

        local_var_def_init = append(
            local_var_def_init,
            list(list(atom("set_local"_sv),
                      var_ident,
                      compile_expression(block->statement.local_var_def.value))));

        block = block->next;
    }

    return append(local_var_def_section, local_var_def_init, compile_block(block));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %r13d, %r13d
movq $0x0, -0x30(%rbp)
testq %r15, %r15
je 0x5446
cmpl $0x0, (%r15)
jne 0x5446
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
movq %rbx, %rdi
callq 0x3fbe
movq %rax, %r12
movq %rbx, %rdi
pushq $0x5
popq %rsi
leaq 0x38e3(%rip), %rdx      # 0x8c8f
callq 0x6716
movq %rax, %r14
movl 0x20(%r15), %esi
movq %rbx, %rdi
callq 0x3fee
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x67aa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6920
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x68c6
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
pushq $0x9
popq %rsi
leaq 0x45ba(%rip), %rdx      # 0x99b6
callq 0x6716
movq %rax, %r14
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x4380
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x67aa
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6920
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x68c6
movq %rax, %r13
movq 0x30(%r15), %r15
jmp 0x5379
movq %rbx, %rdi
movq %r15, %rsi
callq 0x52ee
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x695c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
leaq 0x34a6(%rip), %rdx      # 0x8933
pushq $0x4
popq %rsi
callq 0x6716
movq %rax, %r14
movq 0x10(%rbp), %rcx
movq 0x18(%rbp), %r8
leaq 0x3691(%rip), %rdx      # 0x8b38
pushq $0x1
popq %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6742
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6716
movq %rax, %r15
leaq 0x4528(%rip), %rdx      # 0x99f3
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rax, %r13
movq 0x10(%rbp), %rcx
movq 0x18(%rbp), %r8
movq $0x1, -0x38(%rbp)
leaq 0x34b9(%rip), %rdx      # 0x89a9
movq %rdx, -0x30(%rbp)
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6a1a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6716
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x67fc
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x67aa
movq %rax, %r14
movq 0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x4094
movq %rax, %r15
movl 0x28(%rbp), %esi
movq %rbx, %rdi
callq 0x4148
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6920
movq %rax, %r12
movq 0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x535a
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x69ba
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
testq %r15, %r15
je 0x55eb
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x5472
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6920
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x68c6
movq %rax, %r14
movq 0x30(%r15), %r15
jmp 0x55a0
leaq 0x4408(%rip), %rdx      # 0x99fa
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x6716
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x67d4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movups (%rdi), %xmm0
leaq -0x30(%rbp), %r15
movaps %xmm0, (%r15)
pushq $0x1
popq %r14
pushq $0xa
popq %r12
cmpq $0x0, -0x30(%rbp)
je 0x56a5
movq %r15, %rdi
movl %r12d, %esi
callq 0x6a92
cmpq %rax, %rbx
jbe 0x568f
notq %rax
addq %rax, %rbx
incq %r14
jmp 0x566d
incq %rbx
movq %r14, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43c2(%rip), %rdi      # 0x9a6e
leaq 0x436d(%rip), %rsi      # 0x9a20
leaq 0x440b(%rip), %rcx      # 0x9ac5
pushq $0x16
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x4405(%rip), %rdx      # 0x9b03
pushq $0x3
popq %rsi
movq %rax, %rdi
callq 0x5b90
pushq $0x1
popq %rbx
testb %al, %al
je 0x5714
xorl %eax, %eax
jmp 0x5754
leaq 0x32aa(%rip), %rdx      # 0x89c5
leaq -0x18(%rbp), %rdi
pushq $0x3
popq %rsi
callq 0x5b90
testb %al, %al
je 0x5737
movabsq $0x100000000, %rax      # imm = 0x100000000
jmp 0x5754
leaq 0x43c9(%rip), %rdx      # 0x9b07
leaq -0x18(%rbp), %rdi
pushq $0x6
popq %rsi
callq 0x5b90
movzbl %al, %ebx
movq %rbx, %rax
shlq $0x21, %rax
orq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x439d(%rip), %rsi      # 0x9b0e
callq 0x6af7
leaq 0x43b3(%rip), %rsi      # 0x9b30
movq %rbx, %rdi
callq 0x6af7
leaq 0x43ad(%rip), %rsi      # 0x9b39
movq %rbx, %rdi
callq 0x6af7
leaq 0x43e0(%rip), %rsi      # 0x9b7b
movq %rbx, %rdi
callq 0x6af7
leaq 0x4413(%rip), %rsi      # 0x9bbd
movq %rbx, %rdi
callq 0x6af7
leaq 0x4436(%rip), %rsi      # 0x9bef
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6af7
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c2b
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
shlq $0x4, %rbx
leaq (%r15,%rbx), %rax
cmpq (%rdi), %rax
ja 0x5c44
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 0x41b6(%rip), %rdi      # 0x9de8
leaq 0x41b5(%rip), %rsi      # 0x9dee
leaq 0x4282(%rip), %rcx      # 0x9ec2
pushq $0x13
jmp 0x5c5b
leaq 0x41e9(%rip), %rdi      # 0x9e34
leaq 0x419c(%rip), %rsi      # 0x9dee
leaq 0x4269(%rip), %rcx      # 0x9ec2
pushq $0x14
popq %rdx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
leaq (%r15,%r14), %rbx
movq %r14, %r12
subq $0x1, %r12
jb 0x5dc3
movsbl (%r15), %edi
callq 0x1050
testl %eax, %eax
je 0x5dc0
incq %r15
movq %r12, %r14
jmp 0x5da5
movq %r15, %rbx
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_alexer.cpp
// Function: aids::String_View chop_while<bool (*)(char)>(aids::String_View*, bool (*)(char))
String_View chop_while(String_View *s, Predicate predicate)
{
    size_t n = 0;
    while (n < s->count && predicate(s->data[n])) {
        n += 1;
    }

    String_View chunk = s->subview(0, n);
    s->chop(n);

    return chunk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx), %rcx
cmpq %rcx, %r15
jae 0x5e05
movq 0x8(%rbx), %rax
movsbl (%rax,%r15), %edi
callq *%r14
testb %al, %al
je 0x5e02
incq %r15
jmp 0x5de5
movq (%rbx), %rcx
xorl %eax, %eax
movq %rcx, %rdi
movq 0x8(%rbx), %rsi
movl $0x0, %edx
movl $0x0, %r8d
subq %r15, %rdi
jb 0x5e2a
movq %r15, %rcx
movq %r15, %rax
movq %rsi, %rdx
movq %rdi, %r8
addq %rcx, %rsi
movq %rsi, 0x8(%rbx)
movq %r8, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
cmpq (%rbx), %rcx
jbe 0x5e65
movq %rbx, %rdi
callq 0x71aa
jmp 0x5e4e
movq 0x10(%rbx), %rcx
imulq $0x18, %rax, %rax
movq 0x10(%r14), %rdx
movq %rdx, 0x10(%rcx,%rax)
movups (%r14), %xmm0
movups %xmm0, (%rcx,%rax)
incq 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./././wcc_parser.hpp
// Function: View<Token>::chop(unsigned long)
void chop(size_t n)
    {
        if (n > count) {
            items += count;
            count = 0;
        } else {
            items  += n;
            count -= n;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq %rdx, %rax
subq %rsi, %rax
jae 0x6518
imulq $0x18, %rdx, %rax
addq %rax, %rcx
movq %rcx, 0x8(%rdi)
xorl %eax, %eax
jmp 0x6523
imulq $0x18, %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rdi)
movq %rax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r8
xorl %eax, %eax
testq %r8, %r8
je 0x662e
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdx
movb (%rdx), %cl
xorl %esi, %esi
cmpb $0x2d, %cl
sete %sil
addq %rsi, %rdx
subq %r8, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movq %rsi, %r9
addq %rdi, %r9
je 0x6632
movsbl (%rdx,%rdi), %r9d
addl $-0x30, %r9d
cmpl $0x9, %r9d
ja 0x664e
imull $0xa, %r8d, %r8d
addl %r8d, %r9d
incq %rdi
movl %r9d, %r8d
jmp 0x6608
xorl %edx, %edx
jmp 0x6651
movl %r8d, %edx
negl %edx
cmpb $0x2d, %cl
cmovnel %r8d, %edx
shlq $0x20, %rdx
movabsq $0x1, %rax
jmp 0x6650
xorl %edx, %edx
popq %rbp
orq %rdx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.hpp
// Function: Wat_Compiler::atom(aids::String_View)
S_Expr *atom(String_View name)
    {
        S_Expr *expr = memory->alloc<S_Expr>();
        expr->type = S_Expr_Type::Atom;
        expr->atom.name = name;
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x6df8
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%r13)
addq %rcx, %rsi
incq %rsi
movq %rsi, (%r13)
movq (%rdi), %rdi
callq 0x6e74
movq %rax, 0x8(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x7447
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_wat_compiler.hpp
// Function: Wat_Compiler::cons(S_Expr*, S_Expr*)
S_Expr *cons(S_Expr *head, S_Expr *tail)
    {
        S_Expr *expr = memory->alloc<S_Expr>();
        expr->type = S_Expr_Type::Cons;
        expr->cons.head = head;
        expr->cons.tail = tail;
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x6df8
andl $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
leaq -0x30(%rbp), %rbx
andq $0x0, 0x10(%rbx)
movl %esi, %r14d
movq %rdi, %r15
movq $0x10, (%rbx)
movq (%rdi), %rdi
pushq $0x10
popq %rsi
callq 0x6e74
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1533
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rsi
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6716
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7582
testq %rbx, %rbx
je 0x68f6
movq %rbx, %rdx
cmpl $0x0, (%rdx)
jne 0x6903
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x68df
movq %rax, 0x10(%rcx)
jmp 0x68f9
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2350(%rip), %rdi      # 0x8c5a
leaq 0x36ac(%rip), %rsi      # 0x9fbd
leaq 0x36c0(%rip), %rcx      # 0x9fd8
pushq $0x65
popq %rdx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6ad8
movq (%rdi), %rcx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x6ab4
cmpb %sil, (%rdx,%rax)
je 0x6ab7
incq %rax
jmp 0x6aa4
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 0x1e91(%rip), %rdi      # 0x8970
leaq 0x339a(%rip), %rsi      # 0x9e80
leaq 0x33a2(%rip), %rcx      # 0x9e8f
movl $0x106, %edx            # imm = 0x106
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::String_View aids::unwrap_or_panic<aids::String_View, char const*, char const*, char const*, char*>(aids::Maybe<aids::String_View>, char const*, char const*, char const*, char*)
T unwrap_or_panic(Maybe<T> maybe, Args... args)
    {
        if (!maybe.has_value) {
            println(stderr, args...);
            exit(1);
        }

        return maybe.unwrap;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x10(%rbp)
je 0x6ba0
leaq 0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rdx
popq %rbp
retq
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq 0x742d(%rip), %rax      # 0xdfe0
movq (%rax), %rdi
callq 0x7609
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/tlestang[P]IW_gene/LatticeSite.cpp
// Function: VelSite::init(LatticeSite::SiteType, double, double*, double)
void VelSite::init(SiteType t, double rho, double u[2],
		   double coef_force_)
{
	setType(t);

	coef_force = coef_force_;
	
	for (int k=0; k<q; k++)
		f[k] = fEq(k, rho, u);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
movl %esi, 0x60(%rdi)
movsd %xmm1, 0x68(%rdi)
xorl %r15d, %r15d
movslq 0x50(%r14), %rax
cmpq %rax, %r15
jge 0x2521
movq (%r14), %rax
movq %r14, %rdi
movl %r15d, %esi
movsd 0x8(%rsp), %xmm0
movq %rbx, %rdx
callq *(%rax)
movsd %xmm0, 0x8(%r14,%r15,8)
incq %r15
jmp 0x24f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rsi)
movl 0x50(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x25e6
addsd 0x8(%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rsi)
incq %rcx
jmp 0x25d2
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdx)
xorpd %xmm0, %xmm0
xorl %eax, %eax
leaq 0x2a55(%rip), %rcx      # 0x5050
xorpd %xmm1, %xmm1
cmpq $0x9, %rax
je 0x2632
cvtsi2sdl (%rcx,%rax,8), %xmm2
mulsd 0x8(%rdi,%rax,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, (%rdx)
cvtsi2sdl 0x4(%rcx,%rax,8), %xmm2
mulsd 0x8(%rdi,%rax,8), %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x8(%rdx)
incq %rax
jmp 0x25ff
divsd (%rsi), %xmm1
movsd %xmm1, (%rdx)
divsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x28c8(%rip), %xmm1     # 0x5010
movsd %xmm0, 0x8(%rsp)
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x2942(%rip), %rbp      # 0x50a0
xorl %r13d, %r13d
movslq 0x50(%r12), %rax
cmpq %rax, %r13
jge 0x27f2
leaq 0x28da(%rip), %rax      # 0x5050
cvtsi2sdl 0x4(%rax,%r13,8), %xmm0
movsd (%rbp), %xmm1
mulsd 0x287e(%rip), %xmm1     # 0x5008
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 (%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq *(%rax)
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
addsd 0x58(%r12), %xmm0
movsd %xmm0, 0x8(%r12,%r13,8)
incq %r13
addq $0x8, %rbp
jmp 0x2761
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movsd 0x27f2(%rip), %xmm1     # 0x5010
movsd %xmm0, 0x10(%rsp)
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
xorl %r12d, %r12d
movslq 0x50(%r15), %rax
cmpq %rax, %r12
jge 0x287a
movsd 0x8(%r15,%r12,8), %xmm0
mulsd 0x8(%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 0x10(%rsp), %xmm0
addsd 0x8(%r15,%r12,8), %xmm0
movsd %xmm0, 0x8(%r15,%r12,8)
incq %r12
jmp 0x2831
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x546c(%rip), %rax      # 0x7d18
movq %rax, (%rdi)
movslq (%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movl %r12d, 0x8(%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x10(%r14)
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebp
cmovgl %r12d, %ebp
pushq $0x8
popq %r15
cmpq %r13, %rbp
je 0x28fe
movq %r15, %rdi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x28e4
movq 0x10(%r14), %rax
xorl %ecx, %ecx
cmpl %ecx, %r12d
jle 0x291f
movq (%rax,%rcx,8), %rdx
movl %ecx, (%rdx)
movl 0x4(%rbx), %esi
decl %esi
movl %esi, 0x4(%rdx)
incq %rcx
movl (%rbx), %r12d
jmp 0x2904
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movslq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
xorl %edi, %edi
leaq 0x27ce(%rip), %r8       # 0x5110
cmpq %rax, %rdi
jge 0x298d
movq (%rcx,%rdi,8), %r9
movslq (%r9), %r11
movslq 0x4(%r9), %r9
movq (%rdx,%r11,8), %r10
imulq $0x88, %r9, %r9
addq %r9, %r10
addq $0x8, %r10
addq (%rsi,%r11,8), %r9
xorl %r11d, %r11d
cmpq $0x24, %r11
je 0x2988
movslq (%r11,%r8), %rbx
movsd 0x8(%r9,%rbx,8), %xmm0
movsd %xmm0, (%r10,%r11,2)
addq $0x4, %r11
jmp 0x296b
incq %rdi
jmp 0x2942
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x10(%rdi), %rcx
xorl %esi, %esi
cmpq %rax, %rsi
jge 0x29d8
movq (%rcx,%rsi,8), %rdi
movslq (%rdi), %r8
movslq 0x4(%rdi), %rdi
movq (%rdx,%r8,8), %r8
imulq $0x88, %rdi, %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
jmp 0x299a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rcx
movslq 0x8(%rdi), %r8
movq 0x10(%rdi), %r9
leal 0x1(%r8), %r10d
leal -0x1(%r8), %r11d
xorl %ebx, %ebx
cmpq %r8, %rbx
jge 0x2a5d
movq (%r9,%rbx,8), %rax
movslq (%rax), %r14
movslq 0x4(%rax), %r15
leal (%r10,%r14), %eax
cltd
idivl %r8d
movl %edx, %edi
leal (%r11,%r14), %eax
cltd
idivl %r8d
movslq %edi, %rax
movq (%rsi,%rax,8), %rax
imulq $0x88, %r15, %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
jmp 0x29f4
popq %rbx
popq %r14
popq %r15
retq
nop