LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/StringTools.cpp
// Function: StringTools::_recSplit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void StringTools::_recSplit(std::string instring, vstring &parts,
                            std::string del, bool tokens)
{
    size_t i = !tokens ? instring.find(del) : instring.find_first_of(del);
    if (i == std::string::npos)
    {
        if (!instring.empty())
        {
            parts.add(instring);
        }
        return;
    }
    else if (i > 0 && i < instring.length())
    {
         parts.add(instring.substr(0, i));
    }

    if (!tokens)
    {
        if (i+del.length() <= instring.length())
        {
            _recSplit(instring.substr(i+del.length()), parts, del, tokens);
        }
    }
    else
    {
        if (i+1 <= instring.length())
        {
            _recSplit(instring.substr(i+1), parts, del, tokens);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rsi
xorl %edx, %edx
testl %ecx, %ecx
je 0x6b28
callq 0x3280
jmp 0x6b2d
callq 0x34d0
movq %rax, %r12
testq %rax, %rax
je 0x6b9d
cmpq $-0x1, %r12
jne 0x6b68
cmpq $0x0, 0x8(%r15)
je 0x6c48
leaq -0xe8(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3360
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6ec8
jmp 0x6c40
cmpq 0x8(%r15), %r12
jae 0x6b9d
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r12, %rcx
callq 0x32f0
movq %rbx, %rdi
leaq -0x88(%rbp), %rsi
callq 0x6ec8
leaq -0x88(%rbp), %rdi
callq 0x3340
testb %r13b, %r13b
je 0x6bf4
cmpq 0x8(%r15), %r12
jae 0x6c48
incq %r12
leaq -0xa8(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x32f0
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x3360
leaq -0xa8(%rbp), %r14
leaq -0x48(%rbp), %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6af8
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x6c40
addq 0x8(%r14), %r12
cmpq 0x8(%r15), %r12
ja 0x6c48
leaq -0xc8(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x32f0
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x3360
leaq -0xc8(%rbp), %r14
leaq -0x68(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x6af8
leaq -0x68(%rbp), %rdi
callq 0x3340
movq %r14, %rdi
callq 0x3340
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3340
jmp 0x6c9b
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3340
jmp 0x6cac
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3340
jmp 0x6cb8
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x3340
jmp 0x6cb8
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x3340
jmp 0x6cb8
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x3240
cmpq $-0x1, %rax
je 0x6dd8
movq 0x8(%r14), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x32f0
jmp 0x6de3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $-0x1
popq %rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3490
cmpq $-0x1, %rax
je 0x6e25
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x32f0
jmp 0x6e30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/./MutableArray.h
// Function: MutableArray<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void add(T item)
    {
        if (_count >= _size)
        {
            // increasr the size of the array if we need
            _resize();
        }
        _items[_count++] = item;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
cmpq 0x10(%r14), %rdi
jb 0x6eeb
movq %r14, %rdi
callq 0x6f7a
movq 0x8(%r14), %rdi
leaq 0x1(%rdi), %rax
movq %rax, 0x8(%r14)
shlq $0x5, %rdi
addq (%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3180
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
addq %r15, %r12
movq %r12, %rax
shrq $0x3b, %rax
movq %r12, %r13
shlq $0x5, %r13
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r13, %rdi
orq $0x8, %rdi
callq 0x3030
movq %r12, (%rax)
leaq 0x8(%rax), %r14
testq %r12, %r12
je 0x6fde
addq $0x18, %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
addq $0x20, %rax
addq $-0x20, %r13
jne 0x6fc8
movq (%rbx), %rdi
shlq $0x5, %r15
addq %rdi, %r15
movq %r15, %rsi
movq %r14, %rdx
callq 0x707e
movq %r12, 0x10(%rbx)
movq (%rbx), %r12
testq %r12, %r12
je 0x7033
leaq -0x8(%r12), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%r12), %r13
testq %r13, %r13
je 0x702a
shlq $0x5, %r13
leaq -0x20(%r12), %r15
leaq (%r15,%r13), %rdi
callq 0x3340
addq $-0x20, %r13
jne 0x701b
movq -0x30(%rbp), %rdi
callq 0x3350
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpq $0x20, %r13
je 0x7065
addq $-0x40, %r12
leaq (%r12,%r13), %rdi
callq 0x3340
addq $-0x20, %r13
cmpq $0x20, %r13
jne 0x7052
movq -0x30(%rbp), %rdi
callq 0x3350
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::_init()
void Terrain::_init()
{
    _size = ConsoleTools::get_terminal_size();
    _position = Point<int>::zero();

    shuffle_wind_speed();

    // create a array of terrain heights at every x pos
    int *height_map = new int[get_size().x];
    _gen_terrain(0, get_size().x, height_map);

    // fill in the map with sprites for every x pos
    for (int i = 0; i < get_size().x; ++i)
    {
        for (int h = get_size().y - height_map[i]; h < get_size().y; ++h)
        {
            Sprite *tile = new Sprite(" ");
            tile->set_position(Point<int>(i, h));
            if (h == get_size().y - 1)
            {
                tile->set_bcolor(ConsoleTools::white);
                tile->tag = TERRAIN_ROCK;
                tile->set_texture(" ");
            }
            else
            {
                tile->set_bcolor(ConsoleTools::green);
                tile->tag = TERRAIN_DIRT;
            }
            add_child(tile);
        }
    }

    delete[] height_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
callq 0x3970
movq %rax, 0x20(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x72a0
movq %rbx, %rdi
callq 0x8d2e
shlq $0x20, %rax
movq %rax, %rcx
sarq $0x1e, %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x3030
movq %rax, %r14
movq %rbx, %rdi
callq 0x8d2e
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
movq %r14, -0x38(%rbp)
movq %r14, %rcx
callq 0x72e8
leaq -0x80(%rbp), %r13
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x8d2e
cltq
cmpq %rax, %r15
jge 0x724b
movq %rbx, %rdi
callq 0x8d2e
movq %rax, %r12
shrq $0x20, %r12
movq -0x38(%rbp), %rax
subl (%rax,%r15,4), %r12d
movq %rbx, %rdi
callq 0x8d2e
shrq $0x20, %rax
cmpl %eax, %r12d
jge 0x7243
pushq $0x60
popq %rdi
callq 0x32d0
movq %rax, %r14
movq %r13, %rdi
leaq 0x3f10(%rip), %rsi      # 0xb09d
leaq -0x29(%rbp), %rdx
callq 0x3120
movq %r14, %rdi
movq %r13, %rsi
callq 0x4be2
movq %r13, %rdi
callq 0x3340
movq %r12, %rsi
shlq $0x20, %rsi
orq %r15, %rsi
movq %r14, %rdi
callq 0x8d24
movq %rbx, %rdi
callq 0x8d2e
shrq $0x20, %rax
decl %eax
cmpl %eax, %r12d
jne 0x721d
movq %r13, %rbx
movq %r15, %r13
movq %r14, %rdi
pushq $0x25
popq %rsi
callq 0x638e
movl $0xb, 0x8(%r14)
leaq -0x60(%rbp), %r15
movq %r15, %rdi
leaq 0x3ea8(%rip), %rsi      # 0xb09d
leaq -0x29(%rbp), %rdx
callq 0x3120
movq %r14, %rdi
movq %r15, %rsi
callq 0x63b4
movq %r15, %rdi
callq 0x3340
movq %r13, %r15
movq %rbx, %r13
movq -0x40(%rbp), %rbx
jmp 0x7230
movq %r14, %rdi
pushq $0x20
popq %rsi
callq 0x638e
movl $0xa, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c32
incl %r12d
jmp 0x7163
incq %r15
jmp 0x7139
movq -0x38(%rbp), %rdi
callq 0x3350
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3340
jmp 0x7297
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3340
jmp 0x728f
movq %rax, %rdi
callq 0x3aae
movq %rax, %rbx
jmp 0x7297
movq %rax, %rbx
movq %r14, %rdi
callq 0x32a0
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, -0x38(%rbp)
movl %esi, -0x34(%rbp)
movq %rdi, %r12
callq 0x30d0
movl %eax, %r14d
movq %r12, %rdi
movq %r12, -0x30(%rbp)
callq 0x8d2e
movq %rax, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cltd
idivl %ecx
movl %edx, %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
movl %eax, %r13d
addl $0x5, %r13d
callq 0x30d0
pushq $0x28
popq %rcx
cltd
idivl %ecx
movl %edx, %r14d
addl $0xa, %r14d
callq 0x30d0
movl %eax, %r15d
movq %r12, %rdi
callq 0x8d2e
movq %rax, %rcx
shrq $0x20, %rcx
movl %r15d, %eax
cltd
idivl %ecx
movl %edx, %eax
pushq $0xa
popq %rcx
cltd
idivl %ecx
movl %eax, %r15d
addl $0x5, %r15d
callq 0x30d0
movl %eax, %r12d
movq -0x30(%rbp), %rdi
callq 0x8d2e
movq %rax, %rcx
movl %r12d, %eax
cltd
idivl %ecx
cvtsi2ss %r14d, %xmm0
movss %xmm0, -0x30(%rbp)
cvtsi2ss %edx, %xmm0
movss %xmm0, -0x3c(%rbp)
cvtsi2sd %r13d, %xmm0
movsd %xmm0, -0x50(%rbp)
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x48(%rbp)
movslq -0x34(%rbp), %r14
movslq -0x38(%rbp), %r15
cmpq %r15, %r14
jge 0x7400
cvtsi2ss %r14d, %xmm0
divss -0x30(%rbp), %xmm0
subss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x30b0
mulsd -0x50(%rbp), %xmm0
addsd -0x48(%rbp), %xmm0
andpd 0x3df5(%rip), %xmm0     # 0xb1e0
addsd 0x3dfd(%rip), %xmm0     # 0xb1f0
cvttsd2si %xmm0, %eax
movl %eax, (%rbx,%r14,4)
incq %r14
jmp 0x73bc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x8c28
cmpq 0x8(%rax), %r15
jae 0x7466
movq %r14, %rdi
movq %r15, %rsi
callq 0x8c44
movq %rax, %rdi
callq 0x8d1a
movq %rax, %rcx
shrq $0x20, %rcx
cmpl %ecx, %r12d
cmovll %r12d, %ecx
cmpl %ebx, %eax
cmovnel %r12d, %ecx
incq %r15
movl %ecx, %r12d
jmp 0x7429
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/Terrain.cpp
// Function: Terrain::update(int)
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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x8c28
cmpq 0x8(%rax), %r15
jae 0x76b2
movq %r14, %rdi
movq %r15, %rsi
callq 0x8c44
movq (%rax), %rcx
movq %rax, %rdi
movl %ebx, %esi
callq *0x10(%rcx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x8c44
movq %rax, %rdi
callq 0x8ce2
testb %al, %al
je 0x76ad
movq %r14, %rdi
callq 0x8c28
movq %rax, %rdi
movq %r15, %rsi
callq 0x5460
testq %rax, %rax
je 0x76aa
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
decq %r15
incq %r15
jmp 0x764e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x3bd4(%rip), %rsi      # 0xb32b
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x3120
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x7a5c
leaq 0x3a8a(%rip), %rsi      # 0xb201
movq %rax, %rdi
callq 0x34b0
leaq -0x38(%rbp), %rdi
callq 0x3340
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
jmp 0x77a5
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x7b14
movq %r14, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
nop
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/TextureTools.cpp
// Function: TextureTools::load_texture_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool TextureTools::load_texture_file(std::string filename)
{
    std::string text = StringTools::readall(filename);

    if (text == "$NO FILE")
    {
        return false;
    }

    // put file into map by spliting at "
    vstring textures = StringTools::tokens(text, "\"");

    for (int i = 0; i < textures.get_count(); i+=2)
    {
        std::string key = textures[i];
        std::string texture = StringTools::trim(textures[i + 1], "\n");

        _texture_map[key] = texture;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rsi
leaq -0xf0(%rbp), %rbx
movq %rbx, %rdi
callq 0x3360
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0x6864
leaq -0xf0(%rbp), %rdi
callq 0x3340
leaq 0x39b7(%rip), %rsi      # 0xb1ba
leaq -0x70(%rbp), %rdi
callq 0x5f62
movl %eax, %ebx
testb %al, %al
jne 0x792b
movb %bl, -0x29(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3360
leaq 0x39f5(%rip), %rsi      # 0xb225
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rdx
callq 0x3120
leaq -0x50(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x6a5a
leaq -0x90(%rbp), %rdi
callq 0x3340
leaq -0xb0(%rbp), %rdi
callq 0x3340
xorl %r14d, %r14d
leaq -0xd0(%rbp), %r15
leaq -0x130(%rbp), %r13
leaq -0x110(%rbp), %rbx
leaq -0x150(%rbp), %r12
cmpq %r14, -0x48(%rbp)
jbe 0x791f
movq %r15, %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
callq 0x65f2
incq %r14
movq %r13, %rdi
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
callq 0x65f2
movq %rbx, %rdi
leaq 0x38ff(%rip), %rsi      # 0xb1c5
leaq -0x2a(%rbp), %rdx
callq 0x3120
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x6cc8
movq %rbx, %rdi
callq 0x3340
movq %r13, %rdi
callq 0x3340
leaq 0x99ac(%rip), %rdi      # 0x112a0
movq %r15, %rsi
callq 0x7a5c
movq %rax, %rdi
movq %r12, %rsi
callq 0x3180
movq %r12, %rdi
callq 0x3340
movq %r15, %rdi
callq 0x3340
incq %r14
jmp 0x7891
leaq -0x50(%rbp), %rdi
callq 0x653c
movb -0x29(%rbp), %bl
xorb $0x1, %bl
leaq -0x70(%rbp), %rdi
callq 0x3340
movl %ebx, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3340
jmp 0x795f
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3340
jmp 0x79d5
jmp 0x7980
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x3340
jmp 0x79de
movq %rax, %rbx
jmp 0x79d5
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x3340
jmp 0x7999
movq %rax, %rbx
leaq -0x130(%rbp), %rdi
callq 0x3340
jmp 0x79c0
movq %rax, %rbx
jmp 0x79cc
movq %rax, %rbx
leaq -0x150(%rbp), %rdi
callq 0x3340
jmp 0x79c0
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x3340
leaq -0x50(%rbp), %rdi
callq 0x653c
leaq -0x70(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x989a(%rip), %rdi      # 0x112a0
callq 0x7fe2
leaq 0x9896(%rip), %rcx      # 0x112a8
cmpq %rcx, %rax
je 0x7a33
leaq 0x9882(%rip), %rdi      # 0x112a0
movq %r14, %rsi
callq 0x7a5c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3360
jmp 0x7a46
leaq 0x37ed(%rip), %rsi      # 0xb227
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x3120
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x0, 0x19(%rdi)
je 0x8035
xorl %eax, %eax
retq
movl 0x14(%rdi), %eax
cmpl 0x10(%rdi), %eax
jl 0x8043
cmpb $0x1, 0x18(%rdi)
jne 0x8032
pushq %rbp
movq %rsp, %rbp
callq 0x806e
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/Timer.cpp
// Function: Timer::_wait()
void Timer::_wait()
{
    const std::clock_t start_time = std::clock();
    while ((static_cast<double>((clock() - start_time))/CLOCKS_PER_SEC) < get_delay())
    {
        // wait
    }
    ++_tick_counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x31b0
movq %rax, %r14
callq 0x31b0
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0x319b(%rip), %xmm0     # 0xb230
movsd 0x8(%rbx), %xmm1
ucomisd %xmm0, %xmm1
ja 0x8080
incl 0x14(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x802c
testb %al, %al
je 0x80d2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x80b1
movl 0x14(%rbx), %edx
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
jmp 0x80b1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/Bullet.cpp
// Function: Bullet::_init()
void Bullet::_init()
{
    _fcolor = ConsoleTools::yellow;
    // set inital velocity
    _velocity = Point<float>(_power*cosf(_angle), -_power*std::abs(sinf(_angle)));
    _launched = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x21, 0x58(%rdi)
movss 0x68(%rdi), %xmm0
movss 0x6c(%rdi), %xmm1
movss %xmm1, -0xc(%rbp)
callq 0x31e0
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x6c(%rbx), %xmm0
xorps 0x3057(%rip), %xmm0     # 0xb1d0
movaps %xmm0, -0x20(%rbp)
movss 0x68(%rbx), %xmm0
callq 0x3230
andps 0x2ef2(%rip), %xmm0     # 0xb080
mulss -0x20(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
movss %xmm1, 0x60(%rbx)
movss %xmm0, 0x64(%rbx)
movb $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x813c
movb $0x1, 0x70(%rbx)
movq 0x74(%rbx), %rax
movq %rax, 0x18(%rbx)
leaq 0x308e(%rip), %rsi      # 0xb260
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x39be
leaq -0x30(%rbp), %rdi
callq 0x3340
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3aae
// File: /workspace/github_cpp_makefile_star2_O2/Jacobious52[P]Tanks/View.cpp
// Function: View::update(int)
void View::update(int t)
{
    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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x10(%r14), %rax
cmpq 0x8(%rax), %r15
jae 0x8cd6
movq (%rax), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movl %ebx, %esi
callq *0x10(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq (%rax,%r15,8), %rax
cmpb $0x1, 0x30(%rax)
jne 0x8cd1
movq %r15, %rsi
callq 0x5460
testq %rax, %rax
je 0x8cce
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
decq %r15
incq %r15
jmp 0x8c8e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
pushq $0x60
popq %rdi
callq 0x32d0
movq %rax, %rbx
leaq 0x60(%r14), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3360
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x4be2
leaq -0x30(%rbp), %rdi
callq 0x3340
movq %rbx, %rdi
callq 0x8d2e
pushq $-0x4
popq %rcx
cltd
idivl %ecx
movabsq $-0x200000000, %rsi     # imm = 0xFFFFFFFE00000000
orq %rax, %rsi
movq %rbx, %rdi
callq 0x8d24
movl 0x58(%r14), %esi
movq %rbx, %rdi
callq 0x637a
pushq $0x25
popq %rsi
movq %rbx, %rdi
callq 0x638e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8c32
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x3340
jmp 0x8ed2
movq %rax, %rdi
callq 0x3aae
movq %rax, %r14
movq %rbx, %rdi
callq 0x32a0
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x0, 0x31(%rdi)
je 0x9037
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x23
popq %rdi
callq 0x3884
movq 0x50(%rbx), %r15
leaq 0x40(%rbx), %r12
xorl %esi, %esi
leaq 0x231d(%rip), %r14      # 0xb301
cmpq %r12, %r15
je 0x901c
movl 0x18(%rbx), %edi
leal 0x1(%rsi), %r13d
addl 0x1c(%rbx), %esi
callq 0x390e
movq 0x20(%r15), %rsi
cvtss2sd 0x40(%r15), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x3050
movq %r15, %rdi
callq 0x31c0
movq %rax, %r15
movl %r13d, %esi
jmp 0x8fe4
callq 0x38b4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cec
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x39a2
callq 0x38b4
callq 0x38f2
xorl %edi, %edi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7218(%rip), %rax      # 0x10d88
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x9b87
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9b96
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9ba5
movq (%rdi), %rax
callq *0x8(%rax)
callq 0x38b4
callq 0x38f2
callq 0x39a2
andq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
andq $0x0, 0x28(%rbx)
movq %rax, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x22a0
leaq 0x4ae5(%rip), %rsi      # 0x7068
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2050
leaq -0x210(%rbp), %rsi
movq %rbx, %rdi
callq 0x45bc
leaq 0x8c34(%rip), %rdi      # 0xb1d8
leaq 0x4ab4(%rip), %rsi      # 0x705f
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq -0x210(%rbp), %rdi
callq 0x2360
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x2360
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpl $0x0, (%rdi)
je 0x295f
movq %rsi, %r14
movq %rdi, %rbx
movq 0x868b(%rip), %rdi      # 0xafc8
leaq 0x48de(%rip), %rsi      # 0x7222
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x255c
movl $0x2, (%rbx)
leaq 0x8872(%rip), %rdi      # 0xb1d8
leaq 0x48b0(%rip), %rsi      # 0x721d
callq 0x2170
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x218(%rbp), %r15
movq %r15, %rdi
callq 0x22a0
leaq 0x4880(%rip), %rsi      # 0x72aa
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x2050
movzbl %r14b, %r14d
movq 0x8588(%rip), %rsi      # 0xafc8
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4f0c
movq 0x8576(%rip), %rdi      # 0xafc8
leaq 0x480d(%rip), %rsi      # 0x7266
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq -0x218(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4f0c
movq 0x8549(%rip), %rdi      # 0xafc8
callq 0x20b0
leaq 0x874d(%rip), %rdi      # 0xb1d8
leaq 0x4807(%rip), %rsi      # 0x7299
callq 0x2170
movq %rax, %rdi
callq 0x20b0
leaq -0x218(%rbp), %rdi
callq 0x2360
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2360
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0x78d0(%rip), %rdi      # 0xafc8
leaq 0x3efa(%rip), %rsi      # 0x75f9
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x45a8
movq %rax, %r15
testq %r15, %r15
je 0x3757
movq %rbx, %rdi
callq 0x4a30
movl %eax, %r12d
movq %rbx, %rdi
callq 0x4a3a
movl %eax, %r13d
movq %rbx, %rdi
callq 0x4a44
movq %r15, %rdi
movl %r12d, %esi
movl %r13d, %edx
movl %eax, %ecx
callq 0x4f02
movq %rbx, %rdi
callq 0x255c
movq (%r15), %r15
jmp 0x3717
leaq 0x7a7a(%rip), %rdi      # 0xb1d8
leaq 0x3ec6(%rip), %rsi      # 0x762b
callq 0x2170
movq %rax, %rdi
callq 0x20b0
movzbl %r14b, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29fe
// File: /workspace/github_cpp_makefile_star2_O2/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
orl $-0x1, (%rdi)
andq $0x0, 0x8(%rdi)
orl $-0x1, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
orl $-0x1, 0x20(%rdi)
movb $0x0, 0x24(%rdi)
orq $-0x1, 0x28(%rdi)
orl $-0x1, 0x30(%rdi)
popq %rbp
jmp 0x40c6
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %r15
pushq $0x78
popq %r14
testq %r15, %r15
je 0x4100
movq (%r15), %r12
movq %r15, %rdi
callq 0x4cd2
movq %r15, %rdi
movq %r14, %rsi
callq 0x2190
movq %r12, 0x38(%rbx)
movq %r12, %r15
jmp 0x40dc
movq 0x40(%rbx), %rdi
pushq $0x10
popq %r14
testq %rdi, %rdi
je 0x4122
movq 0x8(%rdi), %r15
movq %r14, %rsi
callq 0x2190
movq %r15, 0x40(%rbx)
movq %r15, %rdi
jmp 0x4108
andl $0x0, 0x48(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x2c(%rbp)
movl %r8d, %r12d
movl %ecx, %r15d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x4066
movl %r14d, (%rbx)
movslq %r14d, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0x417f
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x4171
movl %r13d, 0x10(%rbx)
movslq %r13d, %r13
movq %r13, %rdi
callq 0x2030
movq %rax, 0x18(%rbx)
xorl %ecx, %ecx
testl %r13d, %r13d
cmovlel %ecx, %r13d
cmpq %rcx, %r13
je 0x41a9
movb $0x0, (%rax,%rcx)
incq %rcx
jmp 0x419b
movl %r15d, 0x20(%rbx)
movb $0x0, 0x24(%rbx)
movl %r12d, 0x28(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x2c(%rbx)
testl %r15d, %r15d
jle 0x41c6
movl 0x10(%rbp), %eax
movl %eax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x30(%rbp)
addq $0x40, %rdi
xorl %r14d, %r14d
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r12
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq (%rax), %rbx
testq %rbx, %rbx
je 0x4432
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x4d5e
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x4d5e
movq %r15, %rdi
movq %r12, %rsi
callq 0x4b2e
movl %eax, %r13d
movq %r12, %rdi
callq 0x2358
movq %r15, %rdi
callq 0x2358
testb %r13b, %r13b
jne 0x4432
leaq 0x8(%rbx), %rax
movq %rbx, %r14
jmp 0x43e7
pushq $0x10
popq %rdi
callq 0x2180
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%r14), %rcx
testq %r14, %r14
cmoveq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %rbx, 0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addq $0x38, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x44a2
movq %rbx, %rdi
callq 0x4d38
cmpl %r14d, %eax
jne 0x448d
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %r14
leaq -0x68(%rbp), %r13
leaq -0x48(%rbp), %r12
movq (%r14), %r14
testq %r14, %r14
je 0x456a
movq %rbx, %rdi
leaq 0x3587(%rip), %rsi      # 0x7a6a
callq 0x2170
movq %rax, %r15
movq %r14, %rdi
callq 0x4d38
movq %r15, %rdi
movl %eax, %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x2be7(%rip), %rsi      # 0x70ee
callq 0x2170
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x4d42
movq %r15, %rdi
movq %r13, %rsi
callq 0x2160
movq %rax, %rdi
leaq 0x2df8(%rip), %rsi      # 0x7327
callq 0x2170
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
callq 0x4d5e
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x2358
movq %r13, %rdi
callq 0x2358
jmp 0x44cd
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4589
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2358
jmp 0x458c
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/tbonelaforge[P]gradebook/Gradebook.cpp
// Function: Gradebook::serialize(std::ostream&)
void Gradebook::serialize(ostream& out) {
    out << numPrograms << " ";
    out << numTests << " ";
    out << numFinals << endl;
    out << programsWeight << " ";
    out << testsWeight << " ";
    out << finalExamWeight << endl;
    out << numStudents << endl;
    Student * current = head;
    while (current != NULL) {
        current->serialize(out);
        out << endl;
        current = current->next;
    }
    for (int i = 0; i < numPrograms; i++) {
        out << programRecorded[i] << " ";
    }
    out << endl;
    for (int i = 0; i < numTests; i++) {
        out << testRecorded[i] << " ";
    }
    out << endl;
    out << finalExamRecorded << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %esi
movq %rbx, %rdi
callq 0x22c0
leaq 0x2d49(%rip), %r15      # 0x7327
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl 0x20(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20b0
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl 0x2c(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
movl 0x30(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20b0
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20b0
leaq 0x38(%r14), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x468b
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4e04
movq %rbx, %rdi
callq 0x20b0
jmp 0x466e
xorl %r12d, %r12d
leaq 0x2c92(%rip), %r15      # 0x7327
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x46be
movq 0x8(%r14), %rax
movzbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x2290
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r12
jmp 0x4695
movq %rbx, %rdi
callq 0x20b0
xorl %r12d, %r12d
leaq 0x2c57(%rip), %r15      # 0x7327
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0x46fa
movq 0x18(%r14), %rax
movzbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x2290
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r12
jmp 0x46d0
movq %rbx, %rdi
callq 0x20b0
movzbl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0x2290
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movl %esi, %r13d
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rdx
movq %rdx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
leaq 0x10(%rdi), %rdx
movq %rdx, -0x30(%rbp)
leaq 0x30(%rdi), %r12
movb %al, 0x40(%rdi)
movl %esi, 0x50(%rdi)
movl %r14d, 0x54(%rdi)
movl %ecx, 0x58(%rdi)
movl %esi, %edi
shlq $0x2, %rdi
testl %esi, %esi
pushq $-0x1
popq %r15
cmovsq %r15, %rdi
callq 0x2030
movq %rax, 0x60(%rbx)
movslq %r13d, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x4c6b
orl $-0x1, (%rax,%rdx,4)
incq %rdx
jmp 0x4c5d
movl %r14d, %edi
shlq $0x2, %rdi
testl %r14d, %r14d
cmovsq %r15, %rdi
callq 0x2030
movq %rax, 0x68(%rbx)
movslq %r14d, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x4c95
orl $-0x1, (%rax,%rdx,4)
incq %rdx
jmp 0x4c87
movabsq $-0x407fffff00000001, %rax # imm = 0xBF800000FFFFFFFF
movq %rax, 0x70(%rbx)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x2358
movq -0x30(%rbp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/tbonelaforge[P]gradebook/Student.cpp
// Function: Student::serialize(std::ostream&)
void Student::serialize(ostream& out) {
    out << id << " ";
    out << firstName << " ";
    out << lastName << " ";
    for (int i = 0; i < numPrograms; i++) {
        out << programGrades[i] << " ";
    }
    for (int i = 0; i < numTests; i++) {
        out << testGrades[i] << " ";
    }
    for (int i = 0; i < numFinals; i++) {
        out << finalExamGrade << " ";
    }
    out << finalAverage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x22c0
leaq 0x2500(%rip), %r15      # 0x7327
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
leaq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
xorl %r12d, %r12d
movslq 0x50(%r14), %rax
cmpq %rax, %r12
jge 0x4e8c
movq 0x60(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r12
jmp 0x4e63
xorl %r12d, %r12d
leaq 0x2491(%rip), %r15      # 0x7327
movslq 0x54(%r14), %rax
cmpq %rax, %r12
jge 0x4ebf
movq 0x68(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r12
jmp 0x4e96
xorl %r12d, %r12d
leaq 0x245e(%rip), %r15      # 0x7327
cmpl 0x58(%r14), %r12d
jge 0x4eeb
movl 0x70(%r14), %esi
movq %rbx, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incl %r12d
jmp 0x4ec9
movss 0x74(%r14), %xmm0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/tbonelaforge[P]gradebook/GradebookPrinter.cpp
// Function: GradebookPrinter::print(std::ostream&)
void GradebookPrinter::print(ostream& out) {
    fillHeaders();
    fillStudentData();
    for (int i = 0; i < numRows; i++) {
        for (int j = 0; j < numColumns; j++) {
            out << centerString(cellContents[i][j], columnWidths[j]);
            if (j < numColumns - 1) {
                out << '|';
            }
        }
        out << endl;
        if (i < numRows - 1) {
            printRowSeparator(out);
            out << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
callq 0x5240
movq %r14, %rdi
callq 0x54a8
xorl %r13d, %r13d
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x5047
movq %r13, -0x38(%rbp)
xorl %r13d, %r13d
xorl %ebx, %ebx
movslq 0xc(%r14), %rax
cmpq %rax, %rbx
jge 0x500f
movq 0x10(%r14), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x2240
movq 0x18(%r14), %rax
movl (%rax,%rbx,4), %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5524
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x2160
movq %r12, %rdi
callq 0x2358
movq %r15, %rdi
callq 0x2358
movslq 0xc(%r14), %rax
decq %rax
cmpq %rax, %rbx
jge 0x5006
movq -0x30(%rbp), %rdi
pushq $0x7c
popq %rsi
callq 0x21d0
incq %rbx
addq $0x20, %r13
jmp 0x4fa0
movq -0x30(%rbp), %rdi
callq 0x20b0
movslq 0x8(%r14), %rax
decq %rax
movq -0x38(%rbp), %r13
cmpq %rax, %r13
jge 0x503f
movq %r14, %rdi
movq -0x30(%rbp), %rbx
movq %rbx, %rsi
callq 0x565c
movq %rbx, %rdi
callq 0x20b0
incq %r13
jmp 0x4f8a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2358
jmp 0x5067
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2358
movq %rbx, %rdi
callq 0x22d0