LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Jacobious52[P]Tanks/EndView.cpp
// Function: EndView::draw()
void EndView::draw()
{
    // draw rain
    if (tag == 1)
    {
        for (int i = 0; i < get_size().x; i+=5)
        {
            ConsoleTools::set_fcolor(ConsoleTools::cyan);
            ConsoleTools::set_cursor(Point<int>(i, rand() % get_size().y));
            printf("|");
        }
    }

    // draw children
    View::draw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0xa572
movl $0x0, -0xc(%rbp)
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x106a0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movq %rcx, -0x14(%rbp)
cmpl -0x14(%rbp), %eax
jge 0xa570
movl $0x24, %edi
callq 0x4af0
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x4110
movq -0x30(%rbp), %rdi
movl %eax, -0x38(%rbp)
callq 0x106a0
movl -0x3c(%rbp), %esi
movq %rax, %rcx
movl -0x38(%rbp), %eax
movq %rcx, -0x24(%rbp)
cltd
idivl -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x4ed0
movq -0x1c(%rbp), %rdi
callq 0x4c50
leaq 0x9bc4(%rip), %rdi      # 0x14122
movb $0x0, %al
callq 0x4070
movl -0xc(%rbp), %eax
addl $0x5, %eax
movl %eax, -0xc(%rbp)
jmp 0xa4f5
jmp 0xa572
movq -0x30(%rbp), %rdi
callq 0x105f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::string_width(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int StringTools::string_width(std::string instring)
{
    size_t count = 0;
    count = instring.find_first_of("\n");

    if (count == std::string::npos)
    {
        count = instring.length();
    }

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x930c(%rip), %rsi      # 0x141db
xorl %eax, %eax
movl %eax, %edx
callq 0x41d0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0xaef0
movq -0x18(%rbp), %rdi
callq 0x4500
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::replace_all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::replace_all(std::string instring,
                                     std::string from,
                                     std::string to)
{
    size_t i = 0;
    while ((i = instring.find(from)) != std::string::npos)
    {
        instring.replace(i, from.length(), to);
        i += to.length();
    }
    return instring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rcx, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0xb05a
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x4500
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
movq %rax, %rdx
callq 0x4150
movq -0x50(%rbp), %rdi
callq 0x4500
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xb007
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4190
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::readall(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::readall(std::string filename)
{
    std::ifstream file(filename.c_str());
    std::stringstream ss;
    ss << file.rdbuf();
    if (!file)
    {
        return "$NO FILE";
    }
    file.close();
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rsi, -0x3d0(%rbp)
movq %rdi, %rax
movq -0x3d0(%rbp), %rdi
movq %rax, -0x3c8(%rbp)
movq %rax, %rcx
movq %rcx, -0x3c0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4180
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x4620
leaq -0x3a0(%rbp), %rdi
callq 0x4260
jmp 0xb0dc
leaq -0x390(%rbp), %rax
movq %rax, -0x3e0(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4530
movq %rax, -0x3d8(%rbp)
jmp 0xb0ff
movq -0x3d8(%rbp), %rsi
movq -0x3e0(%rbp), %rdi
callq 0x40e0
jmp 0xb114
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x41c0
movb %al, -0x3e1(%rbp)
jmp 0xb134
movb -0x3e1(%rbp), %al
testb $0x1, %al
jne 0xb143
jmp 0xb1d5
leaq -0x3ad(%rbp), %rdi
movq %rdi, -0x3f0(%rbp)
callq 0x45f0
movq -0x3c8(%rbp), %rdi
movq -0x3f0(%rbp), %rdx
leaq 0x9065(%rip), %rsi      # 0x141d0
callq 0x4490
jmp 0xb172
leaq -0x3ad(%rbp), %rdi
callq 0x4400
movl $0x1, -0x3b4(%rbp)
jmp 0xb202
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
jmp 0xb23c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
jmp 0xb22c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3a8(%rbp)
movl %eax, -0x3ac(%rbp)
leaq -0x3ad(%rbp), %rdi
callq 0x4400
jmp 0xb22c
leaq -0x218(%rbp), %rdi
callq 0x40d0
jmp 0xb1e3
movq -0x3c8(%rbp), %rdi
leaq -0x3a0(%rbp), %rsi
callq 0x4380
jmp 0xb1f8
movl $0x1, -0x3b4(%rbp)
leaq -0x3a0(%rbp), %rdi
callq 0x4290
jmp 0xb210
leaq -0x218(%rbp), %rdi
callq 0x4100
movq -0x3c0(%rbp), %rax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
leaq -0x3a0(%rbp), %rdi
callq 0x4290
jmp 0xb23a
jmp 0xb23c
leaq -0x218(%rbp), %rdi
callq 0x4100
jmp 0xb24a
jmp 0xb24c
movq -0x3a8(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::readlines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vstring StringTools::readlines(std::string filename)
{
    vstring lines;
    std::string line;
    std::ifstream file(filename.c_str());

    if (!file)
    {
        return lines;
    }

    while (getline(file, line))
    {
        lines.add(line);
    }
    file.close();
    return lines;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, -0x290(%rbp)
movq %rdi, -0x288(%rbp)
movq %rdi, %rax
movq %rax, -0x280(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xbcc0
leaq -0x38(%rbp), %rdi
callq 0x44a0
jmp 0xb29f
movq -0x290(%rbp), %rdi
callq 0x4180
movq %rax, -0x298(%rbp)
jmp 0xb2b4
movq -0x298(%rbp), %rsi
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x4620
jmp 0xb2ce
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x41c0
movb %al, -0x299(%rbp)
jmp 0xb2ee
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0xb2fa
jmp 0xb340
movb $0x1, -0x11(%rbp)
movl $0x1, -0x254(%rbp)
jmp 0xb3f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb450
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb427
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xb40f
jmp 0xb342
leaq -0x250(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x40b0
movq %rax, -0x2a8(%rbp)
jmp 0xb35b
movq -0x2a8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4520
movq %rax, -0x2b0(%rbp)
jmp 0xb37a
movq -0x2b0(%rbp), %rax
cmpq $0x0, %rax
je 0xb3da
leaq -0x278(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4190
jmp 0xb399
movq -0x288(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0xbce0
jmp 0xb3ae
leaq -0x278(%rbp), %rdi
callq 0x4200
jmp 0xb3bc
jmp 0xb342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x4200
jmp 0xb3d8
jmp 0xb40f
leaq -0x250(%rbp), %rdi
callq 0x40d0
jmp 0xb3e8
movb $0x1, -0x11(%rbp)
movl $0x1, -0x254(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x4100
jmp 0xb404
leaq -0x38(%rbp), %rdi
callq 0x4200
jmp 0xb41f
leaq -0x250(%rbp), %rdi
callq 0x4100
jmp 0xb41d
jmp 0xb427
testb $0x1, -0x11(%rbp)
jne 0xb440
jmp 0xb434
leaq -0x38(%rbp), %rdi
callq 0x4200
jmp 0xb432
jmp 0xb450
movq -0x288(%rbp), %rdi
callq 0xaaf0
movq -0x280(%rbp), %rax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x288(%rbp), %rdi
callq 0xaaf0
jmp 0xb45e
jmp 0xb460
movq -0x40(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::ltrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::ltrim(std::string instring, std::string whitespaces)
{
    size_t i = instring.find_first_not_of(whitespaces);
    if (i == std::string::npos)
    {
        return instring;
    }
    else
    {
        return instring.substr(i, instring.size());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x42f0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xbb28
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x4190
jmp 0xbb4d
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x4250
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rax, %rcx
callq 0x43c0
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::rtrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string StringTools::rtrim(std::string instring, std::string whitespaces)
{
    size_t i = instring.find_last_not_of(whitespaces);
    if (i == std::string::npos)
    {
        return instring;
    }
    else
    {
        return instring.substr(0, i+1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rax, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $-0x1, %rdx
callq 0x4630
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xbbbb
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x4190
jmp 0xbbd4
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x43c0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::_resize()
void _resize()
    {
        size_t new_size = _size + _increment_size;

        T *new_items = new T[new_size];
        std::copy(_items, _items+_size, new_items);

        _size = new_size;
        delete[] _items;
        _items = new_items;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rcx), %rax
addq 0x18(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4040
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbf1f
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x44a0
jmp 0xbf0a
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0xbefb
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq (%rax), %rsi
movq 0x10(%rax), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0xc090
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xbfb1
movq -0x68(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x70(%rbp)
je 0xbfa8
movq -0x70(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x80(%rbp)
callq 0x4200
jmp 0xbf97
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x70(%rbp)
jne 0xbf84
movq -0x78(%rbp), %rdi
callq 0x4470
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rcx
movq %rax, %rsi
movq -0x60(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x88(%rbp)
je 0xc013
movq -0x88(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x90(%rbp)
callq 0x4200
jmp 0xbffc
movq -0x90(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x88(%rbp)
jne 0xbfe3
movq -0x38(%rbp), %rdi
callq 0x4470
jmp 0xc075
movq -0x68(%rbp), %rcx
movq %rax, %rsi
movq -0x80(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0x98(%rbp)
je 0xc06c
movq -0x98(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4200
jmp 0xc055
movq -0xa0(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x98(%rbp)
jne 0xc03c
movq -0x78(%rbp), %rdi
callq 0x4470
movq -0x20(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::_gen_terrain(int, int, int*)
void Terrain::_gen_terrain(int start, int length, int *height_map)
{
    int amp = (rand() % get_size().y/5) + 5;
    int period = (rand() % 40) + 10;
    int height = (rand() % get_size().y/10) + 5;
    int phase = rand() % get_size().x;

    for (int i = start; i < length; ++i)
    {
        height_map[i] = std::abs(amp*sin(((float)i/(float)period) - phase) + height) + 5;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4110
movq -0x50(%rbp), %rdi
movl %eax, -0x58(%rbp)
callq 0x106a0
movq %rax, %rcx
movl -0x58(%rbp), %eax
movq %rcx, -0x24(%rbp)
cltd
idivl -0x20(%rbp)
movl %edx, %eax
movl $0x5, %ecx
cltd
idivl %ecx
addl $0x5, %eax
movl %eax, -0x1c(%rbp)
callq 0x4110
movl $0x28, %ecx
cltd
idivl %ecx
addl $0xa, %edx
movl %edx, -0x28(%rbp)
callq 0x4110
movq -0x50(%rbp), %rdi
movl %eax, -0x54(%rbp)
callq 0x106a0
movq %rax, %rcx
movl -0x54(%rbp), %eax
movq %rcx, -0x34(%rbp)
cltd
idivl -0x30(%rbp)
movl %edx, %eax
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x5, %eax
movl %eax, -0x2c(%rbp)
callq 0x4110
movq -0x50(%rbp), %rdi
movl %eax, -0x48(%rbp)
callq 0x106a0
movq %rax, %rcx
movl -0x48(%rbp), %eax
movq %rcx, -0x40(%rbp)
cltd
idivl -0x40(%rbp)
movl %edx, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc7a9
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
cvtsi2ssl -0x44(%rbp), %xmm0
cvtsi2ssl -0x28(%rbp), %xmm1
divss %xmm1, %xmm0
cvtsi2ssl -0x38(%rbp), %xmm1
subss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x40f0
movaps %xmm0, %xmm2
movsd -0x60(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x7660
movsd 0x7a5d(%rip), %xmm1     # 0x141e8
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edx
movq -0x18(%rbp), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xc737
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::get_floor(int)
int Terrain::get_floor(int x)
{
    // the minimum y value is the top of the terrian
    int min = INT_MAX;
    LOOPV(i, this)
    {
        Point<int> tile_pos = get_child(i)->get_position();
        if (tile_pos.x == x && tile_pos.y < min)
        {
            min = tile_pos.y;
        }
    }
    return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x7fffffff, -0x10(%rbp) # imm = 0x7FFFFFFF
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x10400
movq %rax, %rdi
callq 0x7680
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xc83a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, %rdi
callq 0x10660
movq %rax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0xc82a
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc82a
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0xc82c
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc7d6
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::update(int)
void Terrain::update(int t)
{
    // update children
    LOOPV(i, this)
    {
        get_child(i)->update(t);
        if (get_child(i)->should_remove_from_parent() == true)
        {
            delete get_children()->remove(i);
            --i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10400
movq %rax, %rdi
callq 0x7680
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xcc78
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, %rdi
callq 0x105d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcc65
movq -0x20(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x8980
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xcc59
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xcc67
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xcbcf
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Jacobious52[P]Tanks/TextureTools.cpp
// Function: TextureTools::_init_map[abi:cxx11]()
std::map<std::string, std::string> TextureTools::_init_map()
{
    std::map<std::string, std::string> map;
    // add a hard coded test value
    map["debug"] = "___________\n***DEBUG***\n-----------";
    return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0xd390
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x45f0
movq -0x50(%rbp), %rdx
leaq 0x7507(%rip), %rsi      # 0x1433f
leaq -0x30(%rbp), %rdi
callq 0x4490
jmp 0xce43
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd3b0
movq %rax, -0x68(%rbp)
jmp 0xce56
movq -0x68(%rbp), %rdi
leaq 0x73a8(%rip), %rsi      # 0x14209
callq 0x4480
jmp 0xce68
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0xce73
leaq -0x31(%rbp), %rdi
callq 0x4400
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xcecc
jmp 0xcec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xceaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0xcead
jmp 0xceaf
leaq -0x31(%rbp), %rdi
callq 0x4400
movq -0x60(%rbp), %rdi
callq 0xd370
jmp 0xced6
movq -0x60(%rbp), %rdi
callq 0xd370
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
jmp 0xced8
movq -0x40(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopl (%rax)
// File: Jacobious52[P]Tanks/TextureTools.cpp
// Function: TextureTools::get_texture(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string TextureTools::get_texture(std::string key)
{
    if (_texture_map.find(key) != _texture_map.end())
    {
        return _texture_map[key];
    }
    else
    {
        return "$NO KEY";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe0a2(%rip), %rdi      # 0x1b368
callq 0xd580
movq %rax, -0x18(%rbp)
leaq 0xe092(%rip), %rdi      # 0x1b368
callq 0xd5b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xd550
testb $0x1, %al
jne 0xd2f2
jmp 0xd310
movq -0x50(%rbp), %rsi
leaq 0xe06b(%rip), %rdi      # 0x1b368
callq 0xd3b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4190
jmp 0xd355
leaq -0x21(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x45f0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x6f03(%rip), %rsi      # 0x1422f
callq 0x4490
jmp 0xd333
leaq -0x21(%rbp), %rdi
callq 0x4400
jmp 0xd355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4400
jmp 0xd35f
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: Jacobious52[P]Tanks/Timer.cpp
// Function: Timer::tick()
bool Timer::tick()
{
    // GET OUT OF THERE!!
    if (_force_break == true)
        return false;

    // tick if not reached count or override on
    if (get_tick_count() < get_ticks() || get_tick_overide() == true)
    {
        _wait();
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x19(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xe997
movb $0x0, -0x1(%rbp)
jmp 0xe9db
movq -0x18(%rbp), %rdi
callq 0xe9f0
movq -0x18(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0xea10
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0xe9c8
movq -0x18(%rbp), %rdi
callq 0xea30
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xe9d7
movq -0x18(%rbp), %rdi
callq 0xea50
movb $0x1, -0x1(%rbp)
jmp 0xe9db
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Timer.cpp
// Function: Timer::start()
void Timer::start()
{
    while (tick())
    {
        if (_delegate != 0)
        {
            // call tick for delegate
            _delegate->timer_did_tick(this, get_tick_count());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe970
testb $0x1, %al
jne 0xeae3
jmp 0xeb0e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xeb0c
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0xe9f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl %eax, %edx
movq (%rdi), %rax
callq *(%rax)
jmp 0xead4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Bullet.cpp
// Function: Bullet::fire()
void Bullet::fire()
{
    _init();
    _launched = true;
    _position = _start_pos;
    ConsoleTools::play_music("fire.wav");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xec50
movq -0x50(%rbp), %rax
movb $0x1, 0x70(%rax)
movq 0x74(%rax), %rcx
movq %rcx, 0x18(%rax)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x45f0
movq -0x48(%rbp), %rdx
leaq 0x553f(%rip), %rsi      # 0x14270
leaq -0x28(%rbp), %rdi
callq 0x4490
jmp 0xed3c
leaq -0x28(%rbp), %rdi
callq 0x4d20
jmp 0xed47
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0xed52
leaq -0x29(%rbp), %rdi
callq 0x4400
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xed88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
jmp 0xed86
jmp 0xed88
leaq -0x29(%rbp), %rdi
callq 0x4400
movq -0x38(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/View.cpp
// Function: View::update(int)
LOOPV(i, this)
    {
        get_child(i)->update(t);
        // remove child if requested by child
        if (get_child(i)->should_remove_from_parent() == true)
        {
            delete get_children()->remove(i);
            --i;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10400
movq %rax, %rdi
callq 0x7680
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x105c8
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10460
movq %rax, %rdi
callq 0x105d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x105b5
movq -0x20(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x8980
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x105a9
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x105b7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1051f
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Jacobious52[P]Tanks/Tank.cpp
// Function: Tank::_init()
void Tank::_init()
{
    // add a name above the tank
    Sprite *name_plate = new Sprite(_name);
    name_plate->set_position(Point<int>(-name_plate->get_size().x/4, -2));
    name_plate->set_fcolor(_fcolor);
    name_plate->set_bcolor(ConsoleTools::white);
    add_child(name_plate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x60, %edi
callq 0x43a0
movq -0x60(%rbp), %rsi
movq %rax, -0x58(%rbp)
movb $0x1, -0x3d(%rbp)
addq $0x60, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4190
jmp 0x10a99
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x72a0
jmp 0x10aa8
movb $0x0, -0x3d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x10ab7
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x106a0
movq %rax, -0x50(%rbp)
xorl %eax, %eax
subl -0x50(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq -0x48(%rbp), %rdi
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x4ed0
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x10680
movq -0x60(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x58(%rax), %esi
callq 0xa670
movq -0x10(%rbp), %rdi
movl $0x25, %esi
callq 0xa6b0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10420
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10b56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4200
jmp 0x10b54
jmp 0x10b56
testb $0x1, -0x3d(%rbp)
jne 0x10b5e
jmp 0x10b67
movq -0x58(%rbp), %rdi
callq 0x4360
jmp 0x10b69
movq -0x38(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nopw (%rax,%rax)
// File: Jacobious52[P]Tanks/DebugView.cpp
// Function: DebugView::draw()
void DebugView::draw()
{
    // don't draw if not in debug mode
    if (show == false)
    {
        return;
    }

    ConsoleTools::set_bcolor(ConsoleTools::magneta);
    int i = 0;
    for (map_iter it = _deb_map.begin(); it != _deb_map.end(); ++it)
    {
        ConsoleTools::set_cursor(_position.x, _position.y + i++);
        printf("%s\t:\t%0.3f\n", it->first.c_str(), it->second);
    }
    ConsoleTools::end_color();

    View::draw();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb 0x31(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x10d56
jmp 0x10e0d
movl $0x23, %edi
callq 0x4b20
movq -0x28(%rbp), %rdi
movl $0x0, -0xc(%rbp)
addq $0x38, %rdi
callq 0x10f50
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x10fb0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10f80
testb $0x1, %al
jne 0x10d9c
jmp 0x10dff
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edi
movl 0x1c(%rax), %esi
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
addl %eax, %esi
callq 0x4c00
leaq -0x18(%rbp), %rdi
callq 0x10fe0
movq %rax, %rdi
callq 0x4180
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10fe0
movq -0x30(%rbp), %rsi
movss 0x20(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3527(%rip), %rdi      # 0x14311
movb $0x1, %al
callq 0x4070
leaq -0x18(%rbp), %rdi
callq 0x11000
jmp 0x10d78
callq 0x4b80
movq -0x28(%rbp), %rdi
callq 0x105f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Jacobious52[P]Tanks/Game.cpp
// Function: signal_handler(int)
void signal_handler(int signum)
{
    ConsoleTools::stop_music();
    ConsoleTools::end_color();
    ConsoleTools::clear_screen();
    std::exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x4cf0
callq 0x4b80
callq 0x4be0
xorl %edi, %edi
callq 0x4440
nopw %cs:(%rax,%rax)
// File: Jacobious52[P]Tanks/Game.cpp
// Function: Game::~Game()
~Game()
    {
        // cleanup
        current_view = 0;

        if (intro_view != 0)
        {
            delete intro_view;
        }

        if (game_view != 0)
        {
            delete game_view;
        }

        if (end_view != 0)
        {
            delete end_view;
        }

        ConsoleTools::end_color();
        ConsoleTools::clear_screen();

        ConsoleTools::stop_music();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x817d(%rip), %rcx      # 0x1ad58
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, 0x10(%rax)
je 0x12c34
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x12c14
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x12c12
jmp 0x12c14
jmp 0x12c34
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
addq $0x28, %rdi
callq 0xcd70
jmp 0x12cbc
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12c64
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x12c62
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x12c60
jmp 0x12c62
jmp 0x12c64
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x12c94
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x12c92
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x12c90
jmp 0x12c92
jmp 0x12c94
callq 0x4b80
jmp 0x12c9b
callq 0x4be0
jmp 0x12ca2
callq 0x4cf0
jmp 0x12ca9
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0xcd70
addq $0x40, %rsp
popq %rbp
retq
jmp 0x12cbe
movq -0x10(%rbp), %rdi
callq 0x45e0
movq %rax, %rdi
callq 0x4ec0
nop
// File: tbonelaforge[P]gradebook/Main.cpp
// Function: saveGrades(Gradebook&)
void saveGrades(Gradebook &gradebook) {
    ofstream saveFile;
    saveFile.open("Grades.dat");
    gradebook.serialize(saveFile);
    
    transLog << "Saved to Grades.dat" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x33c0
movq -0x220(%rbp), %rdi
leaq 0x6948(%rip), %rsi      # 0xa068
movl $0x10, %edx
callq 0x3070
jmp 0x372c
movq -0x8(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x67a0
jmp 0x373e
leaq 0xab33(%rip), %rdi      # 0xe278
leaq 0x6913(%rip), %rsi      # 0xa05f
callq 0x3220
movq %rax, -0x228(%rbp)
jmp 0x375a
movq -0x228(%rbp), %rdi
movq 0xa840(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x376f
leaq -0x208(%rbp), %rdi
callq 0x34a0
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x34a0
movq -0x210(%rbp), %rdi
callq 0x33f0
nop
// File: tbonelaforge[P]gradebook/Main.cpp
// Function: handleQuit(int&, Gradebook&)
void handleQuit(int &state, Gradebook &gradebook) {
    //program hangs if no semester (student) data and no prior Grades.dat
    if (state == 0) {
        transLog << "Quit" << endl;
        return;
    }
    
    cout << "Saving grades and exiting..." << endl;
    saveGrades(gradebook);
    state = 2;
    
    transLog << "Quit" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3c9d
leaq 0xa5f8(%rip), %rdi      # 0xe278
leaq 0x6596(%rip), %rsi      # 0xa21d
callq 0x3220
movq %rax, %rdi
movq 0xa312(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x3cf4
movq 0xa324(%rip), %rdi      # 0xdfc8
leaq 0x6577(%rip), %rsi      # 0xa222
callq 0x3220
movq %rax, %rdi
movq 0xa2ee(%rip), %rsi      # 0xdfa8
callq 0x3250
movq -0x10(%rbp), %rdi
callq 0x36f0
movq -0x8(%rbp), %rax
movl $0x2, (%rax)
leaq 0xa59f(%rip), %rdi      # 0xe278
leaq 0x653d(%rip), %rsi      # 0xa21d
callq 0x3220
movq %rax, %rdi
movq 0xa2b9(%rip), %rsi      # 0xdfa8
callq 0x3250
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tbonelaforge[P]gradebook/Main.cpp
// Function: handleOutputGrades(Gradebook&, bool)
void handleOutputGrades(Gradebook &gradebook, bool idMode) {
    ofstream outfile;
    outfile.open("Grades.out");
    GradebookPrinter::printGradebook(gradebook, cout, idMode);
    cout << "\nOutputing the complete gradebook to Grades.out..." << endl;
    GradebookPrinter::printGradebook(gradebook, outfile, idMode);
    cout << endl;
    
    transLog << "Output grades to Grades.out" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x33c0
movq -0x228(%rbp), %rdi
leaq 0x64c2(%rip), %rsi      # 0xa2aa
movl $0x10, %edx
callq 0x3070
jmp 0x3df4
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %edx
andl $0x1, %edx
movq 0xa1c2(%rip), %rsi      # 0xdfc8
callq 0x7a80
jmp 0x3e0d
movq 0xa1b4(%rip), %rdi      # 0xdfc8
leaq 0x644b(%rip), %rsi      # 0xa266
callq 0x3220
movq %rax, -0x230(%rbp)
jmp 0x3e29
movq -0x230(%rbp), %rdi
movq 0xa171(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x3e3e
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %edx
andl $0x1, %edx
leaq -0x210(%rbp), %rsi
callq 0x7a80
jmp 0x3e57
movq 0xa16a(%rip), %rdi      # 0xdfc8
movq 0xa143(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x3e6c
leaq 0xa405(%rip), %rdi      # 0xe278
leaq 0x641f(%rip), %rsi      # 0xa299
callq 0x3220
movq %rax, -0x238(%rbp)
jmp 0x3e88
movq -0x238(%rbp), %rdi
movq 0xa112(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x3e9d
leaq -0x210(%rbp), %rdi
callq 0x34a0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x34a0
movq -0x218(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: tbonelaforge[P]gradebook/Main.cpp
// Function: handleCalculateGrades(Gradebook&, bool)
void handleCalculateGrades(Gradebook &gradebook, bool idMode) {
    cout << "Calculating the final grades for every student..." << endl;
    Student * student = gradebook.getHead();
    while (student != NULL) {
        student->calculateFinalAverage(
                                       gradebook.getProgramsWeight(),
                                       gradebook.getTestsWeight(),
                                       gradebook.getFinalExamWeight()
                                       );
        saveGrades(gradebook);
        student = student->next;
    }
    transLog << "Final grades calculated" << endl;
    
    handleOutputGrades(gradebook, idMode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x901d(%rip), %rdi      # 0xdfc8
leaq 0x5647(%rip), %rsi      # 0xa5f9
callq 0x3220
movq %rax, %rdi
movq 0x8fe7(%rip), %rsi      # 0xdfa8
callq 0x3250
movq -0x8(%rbp), %rdi
callq 0x6760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x502a
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e10
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e30
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6e50
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl %eax, %ecx
callq 0x78a0
movq -0x8(%rbp), %rdi
callq 0x36f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4fd3
leaq 0x9247(%rip), %rdi      # 0xe278
leaq 0x55f3(%rip), %rsi      # 0xa62b
callq 0x3220
movq %rax, %rdi
movq 0x8f61(%rip), %rsi      # 0xdfa8
callq 0x3250
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3db0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::makeEmpty()
void Gradebook::makeEmpty() {
    numPrograms = -1;
    programRecorded = NULL;
    numTests = -1;
    testRecorded = NULL;
    numFinals = -1;
    finalExamRecorded = false;
    programsWeight = -1;
    testsWeight = -1;
    finalExamWeight = -1;
    deleteStudents();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x18(%rdi)
movl $0xffffffff, 0x20(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x24(%rdi)
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2c(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x30(%rdi) # imm = 0xFFFFFFFF
callq 0x5f40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::deleteStudents()
void Gradebook::deleteStudents() {
    while (head != NULL) {
        Student * next = head->next;
        delete head;
        head = next;
    }
    while (index != NULL) {
        Node * next = index->next;
        delete index;
        index = next;
    }
    numStudents = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5fa1
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5f93
movq -0x28(%rbp), %rdi
callq 0x7450
movq -0x28(%rbp), %rdi
movl $0x78, %esi
callq 0x3240
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x38(%rax)
jmp 0x5f54
jmp 0x5fa3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x5fe8
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5fda
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x3240
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x40(%rax)
jmp 0x5fa3
movq -0x20(%rbp), %rax
movl $0x0, 0x48(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::initialize(int, int, int, int, int, int)
void Gradebook::initialize(int p, int t, int f, int pw, int tw, int fw) {
    makeEmpty();
    numPrograms = p;
    programRecorded = new bool[numPrograms];
    for (int i = 0; i < numPrograms; i++) {
        programRecorded[i] = false;
    }
    numTests = t;
    testRecorded = new bool[numTests];
    for (int i = 0; i < numTests; i++) {
        testRecorded[i] = false;
    }
    numFinals = f;
    finalExamRecorded = false;
    programsWeight = pw;
    testsWeight = tw;
    if (numFinals > 0) {
        finalExamWeight = fw;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5e80
movq -0x30(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movslq (%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jge 0x6076
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6050
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
movslq 0x10(%rax), %rdi
callq 0x3030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x60c2
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x609b
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movb $0x0, 0x24(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x2c(%rax)
cmpl $0x0, 0x20(%rax)
jle 0x60ec
movq -0x30(%rbp), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::addToIndex(Student*)
void Gradebook::addToIndex(Student * newStudent) {
    Node * current = index;
    Node * previous = NULL;
    while (current != NULL) {
        if (current->student->getLastName() > newStudent->getLastName()) {
            break;
        }
        previous = current;
        current = current->next;
    }
    Node * newNode = new Node();
    newNode->student = newStudent;
    newNode->next = NULL;
    if (previous != NULL) {
        previous->next = newNode;
    } else {
        index = newNode;
    }
    newNode->next = current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x650b
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x7590
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x7590
jmp 0x64a5
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7090
movb %al, -0x81(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3498
leaq -0x40(%rbp), %rdi
callq 0x3498
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x64d6
jmp 0x64f2
jmp 0x650b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3498
jmp 0x6583
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x647b
movl $0x10, %edi
callq 0x3230
movq %rax, %rdi
movq %rdi, -0x90(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x3130
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x6562
movq -0x78(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x656e
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::findStudentById(int)
Student * Gradebook::findStudentById(int id) {
    Student * current = head;
    while (current != NULL) {
        if (current->getId() == id) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x65d7
movq -0x20(%rbp), %rdi
callq 0x7540
cmpl -0x14(%rbp), %eax
jne 0x65ca
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x65df
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x65ab
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::printStudents(std::ostream&) const
void Gradebook::printStudents(std::ostream& out) const {
    Student * current = head;
    while (current != NULL) {
        out << "Student " << current->getId() << ": " << current->getFirstName() << " " << current->getLastName() << endl;
        current = current->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6725
movq -0x10(%rbp), %rdi
leaq 0x4445(%rip), %rsi      # 0xaa6a
callq 0x3220
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7540
movq -0x88(%rbp), %rdi
movl %eax, %esi
callq 0x33e0
movq %rax, %rdi
leaq 0x3a9c(%rip), %rsi      # 0xa0ee
callq 0x3220
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x7560
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x3200
movq %rax, -0x70(%rbp)
jmp 0x667f
movq -0x70(%rbp), %rdi
leaq 0x3c9d(%rip), %rsi      # 0xa327
callq 0x3220
movq %rax, -0x90(%rbp)
jmp 0x6698
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x7590
jmp 0x66a7
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3200
movq %rax, -0x98(%rbp)
jmp 0x66c0
movq -0x98(%rbp), %rdi
movq 0x78da(%rip), %rsi      # 0xdfa8
callq 0x3250
jmp 0x66d5
leaq -0x68(%rbp), %rdi
callq 0x3498
leaq -0x38(%rbp), %rdi
callq 0x3498
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x660f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x671a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3498
leaq -0x38(%rbp), %rdi
callq 0x3498
jmp 0x672e
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33f0
nopw (%rax,%rax)
// File: tbonelaforge[P]gradebook/Student.cpp
// Function: Student::Student(int, int, int)
Student::Student(int np, int nt, int nf) {
    numPrograms = np;
    numTests = nt;
    numFinals = nf;
    programGrades = new int[numPrograms];
    for (int i = 0; i < numPrograms; i++) {
        programGrades[i] = -1;
    }
    testGrades = new int[numTests];
    for (int i = 0; i < numTests; i++) {
        testGrades[i] = -1;
    } 
    finalExamGrade = -1;
    finalAverage = -1.0;
    next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x10, %rdi
movq %rdi, -0x50(%rbp)
callq 0x3350
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3350
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x50(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x54(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x58(%rax)
movslq 0x50(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x38(%rbp)
jmp 0x7356
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x60(%rax)
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x50(%rcx), %eax
jge 0x73b6
movq -0x40(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x28(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7369
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3498
movq -0x50(%rbp), %rdi
callq 0x3498
jmp 0x7441
movq -0x40(%rbp), %rax
movslq 0x54(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x58(%rbp)
jmp 0x73df
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x54(%rcx), %eax
jge 0x741c
movq -0x40(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x2c(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x73f2
movq -0x40(%rbp), %rax
movl $0xffffffff, 0x70(%rax) # imm = 0xFFFFFFFF
movss 0x371d(%rip), %xmm0     # 0xab4c
movss %xmm0, 0x74(%rax)
movq $0x0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33f0
nopw (%rax,%rax)