LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x563c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x55a4
leaq 0x5ca2(%rip), %r13      # 0xb244
jmp 0x55c6
cmpl $0x5, %eax
ja 0x567a
movl %eax, %eax
leaq 0x4c9e(%rip), %rcx      # 0xa254
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c86(%rip), %r13      # 0xb24c
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x7, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5abf(%rip), %rdi      # 0xb102
leaq 0x5570(%rip), %rsi      # 0xabba
leaq 0x5b01(%rip), %rcx      # 0xb152
movl $0xc7, %edx
callq 0x1090
leaq 0x5b7f(%rip), %rdi      # 0xb1e1
leaq 0x5551(%rip), %rsi      # 0xabba
leaq 0x5ae2(%rip), %rcx      # 0xb152
movl $0xce, %edx
callq 0x1090
leaq 0x5776(%rip), %rdi      # 0xadf7
leaq 0x5532(%rip), %rsi      # 0xabba
leaq 0x5ac3(%rip), %rcx      # 0xb152
movl $0xda, %edx
callq 0x1090
leaq 0x5ae0(%rip), %rdi      # 0xb180
leaq 0x5513(%rip), %rsi      # 0xabba
leaq 0x5aa4(%rip), %rcx      # 0xb152
movl $0xcb, %edx
callq 0x1090
leaq 0x58ab(%rip), %rdi      # 0xaf6a
leaq 0x54f4(%rip), %rsi      # 0xabba
leaq 0x5a85(%rip), %rcx      # 0xb152
movl $0xd6, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57a4
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x570c
leaq 0x5caf(%rip), %r13      # 0xb3b9
jmp 0x572e
cmpl $0x5, %eax
ja 0x57e2
movl %eax, %eax
leaq 0x4b4e(%rip), %rcx      # 0xa26c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c94(%rip), %r13      # 0xb3c2
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x8, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5aa9(%rip), %rdi      # 0xb254
leaq 0x5408(%rip), %rsi      # 0xabba
leaq 0x5af9(%rip), %rcx      # 0xb2b2
movl $0xe0, %edx
callq 0x1090
leaq 0x5b85(%rip), %rdi      # 0xb34f
leaq 0x53e9(%rip), %rsi      # 0xabba
leaq 0x5ada(%rip), %rcx      # 0xb2b2
movl $0xe7, %edx
callq 0x1090
leaq 0x560e(%rip), %rdi      # 0xadf7
leaq 0x53ca(%rip), %rsi      # 0xabba
leaq 0x5abb(%rip), %rcx      # 0xb2b2
movl $0xf4, %edx
callq 0x1090
leaq 0x5adf(%rip), %rdi      # 0xb2e7
leaq 0x53ab(%rip), %rsi      # 0xabba
leaq 0x5a9c(%rip), %rcx      # 0xb2b2
movl $0xe4, %edx
callq 0x1090
leaq 0x5743(%rip), %rdi      # 0xaf6a
leaq 0x538c(%rip), %rsi      # 0xabba
leaq 0x5a7d(%rip), %rcx      # 0xb2b2
movl $0xf0, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x590c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x5874
leaq 0x5ca5(%rip), %r13      # 0xb517
jmp 0x5896
cmpl $0x5, %eax
ja 0x594a
movl %eax, %eax
leaq 0x49fe(%rip), %rcx      # 0xa284
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c88(%rip), %r13      # 0xb51e
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x6, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5ab8(%rip), %rdi      # 0xb3cb
leaq 0x52a0(%rip), %rsi      # 0xabba
leaq 0x5afe(%rip), %rcx      # 0xb41f
movl $0xfa, %edx
callq 0x1090
leaq 0x5b80(%rip), %rdi      # 0xb4b2
leaq 0x5281(%rip), %rsi      # 0xabba
leaq 0x5adf(%rip), %rcx      # 0xb41f
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq 0x54a6(%rip), %rdi      # 0xadf7
leaq 0x5262(%rip), %rsi      # 0xabba
leaq 0x5ac0(%rip), %rcx      # 0xb41f
movl $0x10c, %edx            # imm = 0x10C
callq 0x1090
leaq 0x5adf(%rip), %rdi      # 0xb44f
leaq 0x5243(%rip), %rsi      # 0xabba
leaq 0x5aa1(%rip), %rcx      # 0xb41f
movl $0xfe, %edx
callq 0x1090
leaq 0x55db(%rip), %rdi      # 0xaf6a
leaq 0x5224(%rip), %rsi      # 0xabba
leaq 0x5a82(%rip), %rcx      # 0xb41f
movl $0x108, %edx            # imm = 0x108
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a74
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x59dc
leaq 0x5c9c(%rip), %r13      # 0xb676
jmp 0x59fe
cmpl $0x5, %eax
ja 0x5ab2
movl %eax, %eax
leaq 0x48ae(%rip), %rcx      # 0xa29c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5c81(%rip), %r13      # 0xb67f
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, (%rax)
movq $0x8, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51b2
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x51b2
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5aaa(%rip), %rdi      # 0xb525
leaq 0x5138(%rip), %rsi      # 0xabba
leaq 0x5af2(%rip), %rcx      # 0xb57b
movl $0x112, %edx            # imm = 0x112
callq 0x1090
leaq 0x5b76(%rip), %rdi      # 0xb610
leaq 0x5119(%rip), %rsi      # 0xabba
leaq 0x5ad3(%rip), %rcx      # 0xb57b
movl $0x118, %edx            # imm = 0x118
callq 0x1090
leaq 0x533e(%rip), %rdi      # 0xadf7
leaq 0x50fa(%rip), %rsi      # 0xabba
leaq 0x5ab4(%rip), %rcx      # 0xb57b
movl $0x124, %edx            # imm = 0x124
callq 0x1090
leaq 0x5ad4(%rip), %rdi      # 0xb5ac
leaq 0x50db(%rip), %rsi      # 0xabba
leaq 0x5a95(%rip), %rcx      # 0xb57b
movl $0x116, %edx            # imm = 0x116
callq 0x1090
leaq 0x5473(%rip), %rdi      # 0xaf6a
leaq 0x50bc(%rip), %rsi      # 0xabba
leaq 0x5a76(%rip), %rcx      # 0xb57b
movl $0x120, %edx            # imm = 0x120
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6584
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 0x5f00
movq %rax, %r12
movq (%r14), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7fb8
movq %rax, %r15
movq 0x30(%rbx), %rbx
testq %rbx, %rbx
jne 0x6525
jmp 0x6587
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_O1/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 0x85c6
movq %rax, -0x38(%rbp)
movl $0x1, %ecx
movl %ecx, (%rax)
movq $0x4, 0x8(%rax)
leaq 0x4160(%rip), %rcx      # 0xa91f
movq %rcx, 0x10(%rax)
movq 0x10(%rbp), %r14
movq 0x18(%rbp), %r8
movq %r8, -0x30(%rbp)
leaq 0x434e(%rip), %rdx      # 0xab24
movl $0x1, %esi
movq %rbx, %rdi
movq %r14, %rcx
callq 0x7df0
movq %rax, %r12
movq %rdx, %r13
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r15
movl $0x1, %eax
movl %eax, (%r15)
movq %r12, 0x8(%r15)
movq %r13, 0x10(%r15)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r12
movl $0x1, %eax
movl %eax, (%r12)
movq $0x6, 0x8(%r12)
leaq 0x51aa(%rip), %rax      # 0xb9df
movq %rax, 0x10(%r12)
movq $0x1, -0x48(%rbp)
leaq 0x414c(%rip), %rdx      # 0xa995
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 0x8158
movq %rax, %r13
movq %rdx, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x1, %ecx
movl %ecx, (%rax)
movq %r13, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7e62
movq %rax, %r14
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
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 0x4dc2
movq %rax, %r14
movl 0x28(%rbp), %esi
movq %rbx, %rdi
callq 0x4e9e
movq %rax, %r12
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x85c6
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 0x6598
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 0x80ca
// File: /workspace/github_cpp_makefile_star2_O1/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 0x69b6
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 0x6784
movq %rax, %r12
movq (%r14), %rdi
movl $0x1, %esi
callq 0x85c6
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7fb8
movq %rax, %rbx
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0x6954
jmp 0x69b8
xorl %ebx, %ebx
movq (%r14), %rdi
movl $0x1, %esi
callq 0x85c6
movq %rax, %r15
movl $0x1, (%rax)
movq $0x6, 0x8(%rax)
leaq 0x5009(%rip), %rax      # 0xb9e6
movq %rax, 0x10(%r15)
movq (%r14), %rdi
movl $0x1, %esi
callq 0x85c6
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_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movups (%rdi), %xmm0
movaps %xmm0, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
sete %bl
je 0x6acc
movq %rsi, %r15
leaq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x81da
leaq 0x1(%r15), %r14
movl $0x1, %ecx
cmpq %r15, %rax
jae 0x6ad1
movl $0x2, %r12d
cmpq $0x0, -0x40(%rbp)
sete -0x29(%rbp)
je 0x6ad4
movq %rax, %r13
notq %r13
addq %r15, %r13
leaq -0x40(%rbp), %rdi
movl $0xa, %esi
movq %rcx, %rbx
movq %rax, -0x48(%rbp)
callq 0x81da
movq %rbx, %rcx
subq -0x48(%rbp), %r15
cmpq %rax, %r13
cmovbeq %r12, %rcx
cmovbeq %r15, %r14
leaq 0x1(%r12), %r12
movq %r13, %r15
ja 0x6a85
jmp 0x6ad4
movb %bl, -0x29(%rbp)
jmp 0x6ad4
movb %bl, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x6aef
movq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f64(%rip), %rdi      # 0xba5a
leaq 0x4f0f(%rip), %rsi      # 0xba0c
leaq 0x4fad(%rip), %rcx      # 0xbab1
movl $0x16, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x3, %rdi
jne 0x6ba5
leaq 0x4f7a(%rip), %rsi      # 0xbaef
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
movl $0x1, %ebx
testl %eax, %eax
je 0x6be1
cmpq $0x3, %r14
jne 0x6ba5
leaq 0x3e1b(%rip), %rsi      # 0xa9b1
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
je 0x6be5
cmpq $0x6, %r14
jne 0x6bc4
leaq 0x4f41(%rip), %rsi      # 0xbaf3
movq %r15, %rdi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
sete %al
jmp 0x6bc6
xorl %eax, %eax
movzbl %al, %ebx
movq %rbx, %rax
shlq $0x21, %rax
orq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x6bd0
movabsq $0x100000000, %rax      # imm = 0x100000000
jmp 0x6bd0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ef9(%rip), %rsi      # 0xbafa
callq 0x8244
leaq 0x4f0f(%rip), %rsi      # 0xbb1c
movq %rbx, %rdi
callq 0x8244
leaq 0x4f09(%rip), %rsi      # 0xbb25
movq %rbx, %rdi
callq 0x8244
leaq 0x4f3c(%rip), %rsi      # 0xbb67
movq %rbx, %rdi
callq 0x8244
leaq 0x4f6f(%rip), %rsi      # 0xbba9
movq %rbx, %rdi
callq 0x8244
leaq 0x4f92(%rip), %rsi      # 0xbbdb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8244
// File: /workspace/github_cpp_makefile_star2_O1/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 0x711b
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
shlq $0x4, %rbx
leaq (%r15,%rbx), %rax
cmpq (%rdi), %rax
ja 0x713a
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 0x4cb0(%rip), %rdi      # 0xbdd2
leaq 0x4caf(%rip), %rsi      # 0xbdd8
leaq 0x4d7c(%rip), %rcx      # 0xbeac
movl $0x13, %edx
callq 0x1090
leaq 0x4cdd(%rip), %rdi      # 0xbe1e
leaq 0x4c90(%rip), %rsi      # 0xbdd8
leaq 0x4d5d(%rip), %rcx      # 0xbeac
movl $0x14, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rbx
movq 0x8(%rdi), %r15
testq %rbx, %rbx
je 0x72cb
leaq (%r15,%rbx), %r14
movsbl (%r15), %edi
callq 0x1050
testl %eax, %eax
je 0x72cb
incq %r15
decq %rbx
jne 0x72b2
xorl %ebx, %ebx
jmp 0x72ce
movq %r15, %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rdx
jbe 0x7339
movl $0x100, %r15d           # imm = 0x100
movq 0x10(%rbx), %rdi
addq %rax, %rax
testq %rdi, %rdi
cmoveq %r15, %rax
movq %rax, (%rbx)
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
callq 0x1160
movq %rax, 0x10(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
cmpq %rax, %rdx
ja 0x7307
movq 0x10(%rbx), %rax
leaq (%rcx,%rcx,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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d3d
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rsi
movb (%rsi), %dl
xorl %edi, %edi
cmpb $0x2d, %dl
sete %dil
cmpq %rdi, %rcx
je 0x7d28
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 0x7d41
leal (%rax,%rax,4), %eax
leal (%r9,%rax,2), %eax
incq %r8
movq %rcx, %r9
addq %r8, %r9
jne 0x7d07
movl %eax, %edi
negl %edi
cmpb $0x2d, %dl
cmovnel %eax, %edi
shlq $0x20, %rdi
movl $0x1, %eax
jmp 0x7d43
xorl %edi, %edi
jmp 0x7d44
xorl %eax, %eax
popq %rbp
orq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
addq %rcx, %rsi
incq %rsi
movq %rsi, (%r13)
movq (%rdi), %rdi
callq 0x864e
movq %rax, 0x8(%r13)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x8e47
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_O1/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 0x864e
movq %rax, %rbx
leaq 0x24c5(%rip), %rdx      # 0xa3ae
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 0x85c6
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_O1/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 0x9080
testq %rbx, %rbx
je 0x7ff4
movq %rbx, %rsi
movl (%rsi), %edx
testl %edx, %edx
jne 0x8001
movq %rsi, %rcx
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x7fd1
testl %edx, %edx
jne 0x8001
cmpq $0x0, 0x10(%rcx)
jne 0x8020
movq %rax, 0x10(%rcx)
jmp 0x7ff7
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2c3e(%rip), %rdi      # 0xac46
leaq 0x3f98(%rip), %rsi      # 0xbfa7
leaq 0x3fac(%rip), %rcx      # 0xbfc2
movl $0x65, %edx
callq 0x1090
leaq 0x3fdf(%rip), %rdi      # 0xc006
leaq 0x3f79(%rip), %rsi      # 0xbfa7
leaq 0x3f8d(%rip), %rcx      # 0xbfc2
movl $0x66, %edx
callq 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8225
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x8202
cmpb %sil, (%rdx,%rax)
je 0x8202
incq %rax
cmpq %rax, %rcx
jne 0x81f1
movq %rcx, %rax
leaq 0x1(%rax), %r8
movq %rcx, %rsi
subq %r8, %rsi
jae 0x8219
addq %rdx, %rcx
movq %rcx, 0x8(%rdi)
xorl %esi, %esi
jmp 0x8220
addq %rdx, %r8
movq %r8, 0x8(%rdi)
movq %rsi, (%rdi)
popq %rbp
retq
leaq 0x2730(%rip), %rdi      # 0xa95c
leaq 0x3c37(%rip), %rsi      # 0xbe6a
leaq 0x3c3f(%rip), %rcx      # 0xbe79
movl $0x106, %edx            # imm = 0x106
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
movsd (%rsi), %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
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
divsd (%rsi), %xmm0
movsd %xmm0, (%rdx)
divsd (%rsi), %xmm1
movsd %xmm1, 0x8(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2835
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movsd 0x387f(%rip), %xmm0     # 0x6010
subsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x38fd(%rip), %rbp      # 0x60a0
xorl %r13d, %r13d
leaq 0x38a3(%rip), %rax      # 0x6050
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rax,%r13,8), %xmm0
movsd (%rbp), %xmm1
mulsd 0x3844(%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 0x27a6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28c2
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movsd 0x37a4(%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 0x287b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6417(%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 0x293c
xorl %r12d, %r12d
movl $0x8, %edi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2922
cmpl $0x0, (%rbx)
jle 0x295c
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 0x2947
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29cd
pushq %rbx
movq 0x10(%rdi), %rcx
xorl %edi, %edi
leaq 0x378f(%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 0x29a9
incq %rdi
cmpq %rax, %rdi
jne 0x2981
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a29
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 0x38(%r8,%rdi), %xmm0
movsd %xmm0, 0x40(%r8,%rdi)
movsd 0x18(%r8,%rdi), %xmm0
movsd 0x30(%r8,%rdi), %xmm1
movsd %xmm0, 0x28(%r8,%rdi)
movsd %xmm1, 0x48(%r8,%rdi)
incq %rsi
cmpq %rsi, %rax
jne 0x29dd
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2abd
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 0x2a4d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c1c
movq %rdx, %rbx
xorl %ecx, %ecx
leaq 0x3669(%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)
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 0x3480(%rip), %xmm1     # 0x6028
addsd %xmm2, %xmm2
addsd 0x345c(%rip), %xmm2     # 0x6010
mulsd %xmm1, %xmm2
movq (%rbx,%r15,8), %rax
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
addq %r13, %rax
movsd %xmm1, 0x8(%rax,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x2b73
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jl 0x2aec
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60e7(%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 0x2c8c
xorl %r12d, %r12d
movl $0x8, %edi
callq 0x2030
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x2c72
cmpl $0x0, (%rbx)
jle 0x2cab
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 0x2c97
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::FreeSlipBC(VelSite**, VelSite**)
void BottomWall::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[6] = _sites[x][y].f[7];
      _sites[x][y].f[2] = _sites[x][y].f[4];
      _sites[x][y].f[5] = _sites[x][y].f[8];
    }
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x2d79
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 0x28(%r8,%rdi), %xmm0
movsd 0x40(%r8,%rdi), %xmm1
movsd %xmm1, 0x38(%r8,%rdi)
movsd %xmm0, 0x18(%r8,%rdi)
movsd 0x48(%r8,%rdi), %xmm0
movsd %xmm0, 0x30(%r8,%rdi)
incq %rsi
cmpq %rsi, %rax
jne 0x2d2d
retq
// File: /workspace/github_cpp_makefile_star2_O1/tlestang[P]IW_gene/Walls.cpp
// Function: BottomWall::TemperatureBC(VelSite**, ThermalSite**, double**, double***)
void BottomWall::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 Tsup, rho, ub[2], usup[2];
  for (int i=0;i<nbNodes;i++)
    {
      double eu;
      x = nodes[i][0]; y = nodes[i][1];

      thermalSites[x][y+1].computeRhoAndU(Tsup);
      velSites[x][y+1].computeRhoAndU(rho, usup);
      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] = (Tsup/4.)*(1.+ 2.*eu) + thermalSites[x][y+1].f[k]
	    - thermalSites[x][y+1].fEq(k,Tsup,usup);
	}
    }
}

// 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 0x2ed8
movq %rdx, %rbx
xorl %ecx, %ecx
leaq 0x33ad(%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)
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 0x31c4(%rip), %xmm1     # 0x6028
addsd %xmm2, %xmm2
addsd 0x31a0(%rip), %xmm2     # 0x6010
mulsd %xmm1, %xmm2
movq (%rbx,%r15,8), %rax
leaq (%rax,%rbp), %rdi
leaq (%rax,%r13), %rcx
addsd 0x78(%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
addq %r13, %rax
movsd %xmm1, 0x8(%rax,%r12,8)
incq %r12
cmpq $0x4, %r12
jne 0x2e2f
movq 0x18(%rsp), %rcx
incq %rcx
movq 0x8(%rsp), %rdi
movslq 0x8(%rdi), %rax
cmpq %rax, %rcx
jl 0x2da8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tlestang[P]IW_gene/LatticeBoltzmann.cpp
// Function: LatticeBoltzmann::generateGeometry()
void LatticeBoltzmann::generateGeometry()
{
	double u[2] = {u0, 0};
	double a = N2/coef_force; double TT;
	
	for (int x=0; x<dims[0]; x++)
	{
		for (int y=0; y<dims[1]; y++)
		{
		  //u[0] = InitialCondition_X(x,y);
		  //u[1] = InitialCondition_Y(x,y);
		  
		  velSites[x][y].init(LatticeSite::Fluid, 1.0, u,
				      coef_force);
		  velSites_[x][y].init(LatticeSite::Fluid, 1.0, u,
				       coef_force);
		  
		  TT = a*y;
		  T[x][y]=TT;
		  thermalSites[x][y].init(LatticeSite::Fluid, TT, u,
					  coef_force);
		  thermalSites_[x][y].init(LatticeSite::Fluid, TT, u,
					   coef_force);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpl $0x0, (%rdi)
jle 0x3c0e
movq %rdi, %rbx
movsd 0x28(%rdi), %xmm0
divsd 0x18(%rdi), %xmm0
movsd %xmm0, (%rsp)
xorl %r15d, %r15d
leaq 0x10(%rsp), %r14
cmpl $0x0, 0x4(%rbx)
jle 0x3bff
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x60(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r12), %rax
addq %r12, %rdi
movl $0x66, %esi
movsd 0x24bc(%rip), %xmm0     # 0x6010
movq %r14, %rdx
callq *0x18(%rax)
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r12), %rax
addq %r12, %rdi
movl $0x66, %esi
movsd 0x2495(%rip), %xmm0     # 0x6010
movq %r14, %rdx
callq *0x18(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd (%rsp), %xmm0
movq 0x50(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%rbp,8)
movsd %xmm0, 0x8(%rsp)
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r13), %rax
addq %r13, %rdi
movl $0x66, %esi
movq %r14, %rdx
callq *0x18(%rax)
movq 0x78(%rbx), %rax
movq (%rax,%r15,8), %rdi
movsd 0x18(%rbx), %xmm1
movq (%rdi,%r13), %rax
addq %r13, %rdi
movl $0x66, %esi
movsd 0x8(%rsp), %xmm0
movq %r14, %rdx
callq *0x18(%rax)
incq %rbp
movslq 0x4(%rbx), %rax
addq $0x70, %r13
addq $0x88, %r12
cmpq %rax, %rbp
jl 0x3b33
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x3b21
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop