LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tsoding[P]wcc/src/./wcc_wat_compiler.cpp
// Function: Wat_Compiler::compile_args_list(Args_List*)
S_Expr *Wat_Compiler::compile_args_list(Args_List *args_list)
{
    S_Expr *result = nullptr;
    S_Expr *last = nullptr;

    while (args_list) {
        S_Expr *node = cons(compile_var_def(args_list->var_def), nullptr);

        if (result == nullptr) {
            result = node;
        } else {
            assert(last);
            assert(last->type == S_Expr_Type::Cons);
            last->cons.tail = node;
        }

        last = node;

        args_list = args_list->next;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6c90
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x6ad0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb720
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6c19
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c77
cmpq $0x0, -0x20(%rbp)
je 0x6c22
jmp 0x6c41
leaq 0x82e1(%rip), %rdi      # 0xef0a
leaq 0x8288(%rip), %rsi      # 0xeeb8
movl $0x56, %edx
leaq 0x82d3(%rip), %rcx      # 0xef0f
callq 0x10c0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6c4c
jmp 0x6c6b
leaq 0x82f1(%rip), %rdi      # 0xef44
leaq 0x825e(%rip), %rsi      # 0xeeb8
movl $0x57, %edx
leaq 0x82a9(%rip), %rcx      # 0xef0f
callq 0x10c0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6ba8
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8fc5
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movl $0x30, %edx
callq 0x10d0
movq -0x50(%rbp), %rdi
movups -0x48(%rbp), %xmm0
movups -0x38(%rbp), %xmm1
movups -0x28(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x86f0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xba10
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0xb8f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x8f53
movq -0x18(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xf0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq 0x5a21(%rip), %rdi      # 0xec1d
movl $0x4, %esi
callq 0x12e0
movq -0xb8(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xb5c0
movq %rax, -0xd0(%rbp)
leaq 0x5bf2(%rip), %rdi      # 0xee22
movl $0x1, %esi
callq 0x12e0
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0xb620
movq -0xb8(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb5c0
movq %rax, -0xc8(%rbp)
leaq 0x6a66(%rip), %rdi      # 0xfd07
movl $0x6, %esi
callq 0x12e0
movq -0xb8(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xb5c0
movq %rax, -0xd8(%rbp)
leaq 0x59be(%rip), %rdi      # 0xec93
movl $0x1, %esi
callq 0x12e0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
movq (%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq 0x5989(%rip), %rdi      # 0xec93
movl $0x1, %esi
callq 0x12e0
movq -0xb8(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq %rdx, -0x90(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %r8
leaq -0x98(%rbp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0xbd10
movq -0xb8(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0xb5c0
movq -0xd8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
movq %rax, %rdx
callq 0xb780
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
callq 0xb6d0
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0xb0(%rbp)
movq 0x10(%rax), %rsi
callq 0x6b80
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0xa8(%rbp)
movl 0x18(%rax), %esi
callq 0x6ca0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0xba10
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq 0x20(%rax), %rsi
callq 0x8fe0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
movq %rax, %r8
callq 0xbbe0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x94ed
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x30, %edx
callq 0x10d0
movq -0x68(%rbp), %rdi
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups -0x30(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x91d0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xba10
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0xb8f0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x947b
leaq 0x681a(%rip), %rdi      # 0xfd0e
movl $0x6, %esi
callq 0x12e0
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0xb5c0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xb720
addq $0xa0, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x9624
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0xbdf0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x48(%rbp), %rax
ja 0x9603
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
incq %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x95bb
leaq 0x6757(%rip), %rdi      # 0xfd82
leaq 0x6702(%rip), %rsi      # 0xfd34
movl $0x16, %edx
leaq 0x679b(%rip), %rcx      # 0xfdd9
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: tsoding[P]wcc/src/./wcc_main.cpp
// Function: print1(_IO_FILE*, Target)
void print1(FILE *stream, Target target)
{
    switch (target) {
    case Target::Wat: print1(stream, "wat"); break;
    case Target::Ast: print1(stream, "ast"); break;
    case Target::Tokens: print1(stream, "tokens"); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x967f
jmp 0x966b
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x9691
jmp 0x9675
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x96a3
jmp 0x96b3
movq -0x8(%rbp), %rdi
leaq 0x678d(%rip), %rsi      # 0xfe17
callq 0x1bb0
jmp 0x96b3
movq -0x8(%rbp), %rdi
leaq 0x5613(%rip), %rsi      # 0xecaf
callq 0x1bb0
jmp 0x96b3
movq -0x8(%rbp), %rdi
leaq 0x676d(%rip), %rsi      # 0xfe1b
callq 0x1bb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6740(%rip), %rdi      # 0xfe17
movl $0x3, %esi
callq 0x12e0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x9700
jmp 0x9710
movb $0x1, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0x9795
leaq 0x5598(%rip), %rdi      # 0xecaf
movl $0x3, %esi
callq 0x12e0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x9740
jmp 0x974d
movb $0x1, -0x8(%rbp)
movl $0x1, -0x4(%rbp)
jmp 0x9795
leaq 0x66c7(%rip), %rdi      # 0xfe1b
movl $0x6, %esi
callq 0x12e0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0xa0b0
testb $0x1, %al
jne 0x977d
jmp 0x978a
movb $0x1, -0x8(%rbp)
movl $0x2, -0x4(%rbp)
jmp 0x9795
movb $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x666b(%rip), %rsi      # 0xfe22
callq 0xbeb0
movq -0x8(%rbp), %rdi
leaq 0x667d(%rip), %rsi      # 0xfe44
callq 0xbeb0
movq -0x8(%rbp), %rdi
leaq 0x6676(%rip), %rsi      # 0xfe4d
callq 0xbeb0
movq -0x8(%rbp), %rdi
leaq 0x66a8(%rip), %rsi      # 0xfe8f
callq 0xbeb0
movq -0x8(%rbp), %rdi
leaq 0x66da(%rip), %rsi      # 0xfed1
callq 0xbeb0
movq -0x8(%rbp), %rdi
leaq 0x66fc(%rip), %rsi      # 0xff03
callq 0xbeb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xa1a1
jmp 0xa1c0
leaq 0x5f75(%rip), %rdi      # 0x1011d
leaq 0x5f74(%rip), %rsi      # 0x10123
movl $0x13, %edx
leaq 0x603c(%rip), %rcx      # 0x101f7
callq 0x10c0
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
cmpq (%rcx), %rax
ja 0xa1da
jmp 0xa1f9
leaq 0x5f88(%rip), %rdi      # 0x10169
leaq 0x5f3b(%rip), %rsi      # 0x10123
movl $0x14, %edx
leaq 0x6003(%rip), %rcx      # 0x101f7
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0xc830
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
callq 0x10b0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tsoding[P]wcc/src/./aids.hpp
// Function: aids::String_View::chop(unsigned long)
void chop(size_t n)
        {
            if (n > count) {
                data += count;
                count = 0;
            } else {
                data  += n;
                count -= n;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jbe 0xa4b5
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
jmp 0xa4d2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0xa520
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x1050
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa529
jmp 0xa543
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa4ff
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0xa5a3
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %edi
callq *%rax
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xa5ac
jmp 0xa5ba
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa578
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xa420
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa480
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x1, %rax
cmpq (%rcx), %rax
jbe 0xa628
movq -0x10(%rbp), %rdi
callq 0xca80
jmp 0xa60c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x10(%rax), %rcx
imulq $0x18, 0x8(%rax), %rsi
addq %rsi, %rcx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jbe 0xb249
movq -0x18(%rbp), %rax
movq (%rax), %rcx
imulq $0x18, %rcx, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rax)
jmp 0xb26a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb3c1
movb $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0xb43a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xb3e2
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xa480
jmp 0xb3e4
cmpq $0x0, -0x28(%rbp)
je 0xb42c
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x11e8
cmpl $0x0, %eax
jne 0xb409
movb $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
jmp 0xb43a
imull $0xa, -0x18(%rbp), %eax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xa480
jmp 0xb3e4
movb $0x1, -0x8(%rbp)
movl -0x18(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xc440
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rdx
leaq 0x1(%rcx,%rdx), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0xc510
movq %rax, -0x48(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r8
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xce90
movq -0x78(%rbp), %rdi
callq 0xa020
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0xc440
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10b0
movq -0x40(%rbp), %rax
movq $0x10, -0x28(%rbp)
movq (%rax), %rdi
movl $0x10, %esi
callq 0xc510
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0xc5d0
leaq -0x28(%rbp), %rdi
callq 0xa020
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xb5c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb929
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xba03
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x31(%rbp)
je 0xb95a
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x31(%rbp)
jne 0xb95a
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb963
jmp 0xb971
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xb931
cmpq $0x0, -0x30(%rbp)
je 0xb97a
jmp 0xb999
leaq 0x3589(%rip), %rdi      # 0xef0a
leaq 0x496a(%rip), %rsi      # 0x102f2
movl $0x64, %edx
leaq 0x4979(%rip), %rcx      # 0x1030d
callq 0x10c0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xb9a4
jmp 0xb9c3
leaq 0x3599(%rip), %rdi      # 0xef44
leaq 0x4940(%rip), %rsi      # 0x102f2
movl $0x65, %edx
leaq 0x494f(%rip), %rcx      # 0x1030d
callq 0x10c0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb9d0
jmp 0xb9ef
leaq 0x497a(%rip), %rdi      # 0x10351
leaq 0x4914(%rip), %rsi      # 0x102f2
movl $0x66, %edx
leaq 0x4923(%rip), %rcx      # 0x1030d
callq 0x10c0
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
je 0xbe13
jmp 0xbe32
leaq 0x2e40(%rip), %rdi      # 0xec5a
leaq 0x4394(%rip), %rsi      # 0x101b5
movl $0x106, %edx            # imm = 0x106
leaq 0x4397(%rip), %rcx      # 0x101c4
callq 0x10c0
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x31(%rbp)
jae 0xbe68
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xbe71
jmp 0xbe7f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xbe3a
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x8(%rbp)
movq -0x28(%rbp), %rsi
incq %rsi
callq 0xa480
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tsoding[P]wcc/src/./aids.hpp
// Function: aids::Args::shift()
char *shift()
        {
            char *result = *argv;
            argv += 1;
            argc -= 1;
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: 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
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
testb $0x1, (%rax)
jne 0xc07e
movq 0x7f84(%rip), %rax      # 0x13fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xd250
movl $0x1, %edi
callq 0x1120
movq -0x38(%rbp), %rax
movups 0x8(%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
callq 0x3760
movq -0x38(%rbp), %rax
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x68(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x374c
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3712
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x392b
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x38fa
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x9, -0x20(%rbp)
jge 0x39bd
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movslq -0x20(%rbp), %rdx
leaq 0x56f8(%rip), %rcx      # 0x9060
cvtsi2sdl (%rcx,%rdx,8), %xmm2
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movslq -0x20(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movslq -0x20(%rbp), %rcx
leaq 0x56ca(%rip), %rax      # 0x9060
cvtsi2sdl 0x4(%rax,%rcx,8), %xmm2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3949
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x5416(%rip), %xmm1     # 0x9038
mulsd %xmm1, %xmm0
movsd 0x53fa(%rip), %xmm1     # 0x9028
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x50(%rbp), %rcx
movl -0x44(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x3d62
movq -0x50(%rbp), %rdi
movslq -0x44(%rbp), %rcx
leaq 0x5403(%rip), %rax      # 0x9060
cvtsi2sdl (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
movslq -0x44(%rbp), %rcx
leaq 0x53eb(%rip), %rax      # 0x9060
cvtsi2sdl 0x4(%rax,%rcx,8), %xmm1
movq -0x20(%rbp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
mulsd 0x68(%rdi), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movslq -0x44(%rbp), %rcx
movsd 0x5369(%rip), %xmm0     # 0x9020
leaq 0x53f2(%rip), %rax      # 0x90b0
mulsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm0
mulsd 0x68(%rdi), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm0
movslq -0x44(%rbp), %rcx
leaq 0x537d(%rip), %rax      # 0x9060
cvtsi2sdl 0x4(%rax,%rcx,8), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rdi)
movslq -0x44(%rbp), %rax
movsd 0x8(%rdi,%rax,8), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x531f(%rip), %xmm0     # 0x9028
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movl -0x44(%rbp), %esi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
movsd -0x60(%rbp), %xmm2
movq -0x50(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd 0x58(%rax), %xmm0
movslq -0x44(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3c3e
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x3e16
movq -0x38(%rbp), %rdi
movsd 0x5274(%rip), %xmm0     # 0x9028
subsd -0x28(%rbp), %xmm0
movslq -0x2c(%rbp), %rax
mulsd 0x8(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x8(%rdi,%rax,8)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x2c(%rbp), %esi
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movslq -0x2c(%rbp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3d9c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3e20
movq -0x28(%rbp), %rax
leaq 0x7e98(%rip), %rcx      # 0xbd00
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3ee3
movl $0x8, %edi
callq 0x3030
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3eaf
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3f3e
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, (%rcx)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ef1
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x51a9(%rip), %rsi      # 0x9130
movl $0x24, %edx
callq 0x31c0
movl $0x0, -0x54(%rbp)
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4044
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x54(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0x9, -0x58(%rbp)
jge 0x4034
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movslq -0x50(%rbp,%rcx,4), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movslq -0x58(%rbp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x3fd6
jmp 0x4036
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x3f98
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x416e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x40(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x28(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x30(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x48(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x406f
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x42ae
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq 0x10(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
addl 0x8(%rcx), %eax
cltd
idivl 0x8(%rcx)
movl %edx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
addl 0x8(%rcx), %eax
cltd
idivl 0x8(%rcx)
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x38(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x40(%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x18(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x28(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x30(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x48(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x418f
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3e20
movq -0x28(%rbp), %rax
leaq 0x77d8(%rip), %rcx      # 0xbd20
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x45c3
movl $0x8, %edi
callq 0x3030
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x458f
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x4618
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movl %edx, (%rcx)
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x4(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x45d1
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x483e
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x40(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x38(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x18(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd 0x48(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
imulq $0x88, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x30(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x473f
popq %rbp
retq