LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::F(int)
long long Population::F(int x){
    long long ret = 0;
    for(int i = 0; i < population[x].chromosome.size() - 1; i++){
        int u = population[x].chromosome[i];
        int v = population[x].chromosome[i + 1];
        ret += weight[u][v];
    }
    return ret;
}

// Assembly:
movslq %esi, %rax
movq 0x10(%rdi), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rcx
movq 0x8(%rdx,%rax,8), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq $0x1, %rdx
je 0x200c
movq 0x28(%rdi), %rsi
movl (%rcx), %r8d
movl $0x1, %edi
xorl %eax, %eax
movslq %r8d, %r8
movslq (%rcx,%rdi,4), %r9
leaq (%r8,%r8,2), %r8
movq (%rsi,%r8,8), %r8
addq (%r8,%r9,8), %rax
incq %rdi
movl %r9d, %r8d
cmpq %rdi, %rdx
jne 0x1fed
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/gabrielfelipeg[P]TravellingSalesman-GeneticAlgo/src/population.cpp
// Function: Population::reproduce()
void Population::reproduce(){
    std::random_shuffle(population.begin(), population.end());

    int sz = population.size();

    // crossing over
    for(int i = 0; i < sz; i += 2){
        std::pair < Individual, Individual > cross = crossingOver(population[i], population[i + 1]);
        population.emplace_back(cross.first);
        population.emplace_back(cross.second);
    }
    // mutation
    for(int i = 0; i < population.size(); i++){
        double random = ((double)rand()) / RAND_MAX;
        if(random <= 0.1){
            population[i].mutate();
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
cmpq %r12, %r15
je 0x297c
leaq 0x18(%r15), %rax
cmpq %r12, %rax
je 0x297f
movl $0x18, %r13d
callq 0x1040
cltq
movq %r13, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
incq %rcx
cqto
idivq %rcx
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %r14
cmpq %r14, %r13
je 0x295d
leaq (%r15,%r13), %rdi
addq %r15, %r14
movq 0x10(%r15,%r13), %rbp
movups (%r15,%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %r14, %rsi
callq 0x3cc2
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movapd 0x30(%rsp), %xmm0
movupd %xmm0, (%r14)
movq %rbp, 0x10(%r14)
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
testq %rdi, %rdi
je 0x295d
subq %rdi, %rsi
callq 0x1130
leaq (%r15,%r13), %rax
addq $0x18, %rax
addq $0x18, %r13
cmpq %r12, %rax
jne 0x28dd
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
jmp 0x297f
movq %r15, %r12
leaq 0x10(%rbx), %r14
movq %r12, %rax
subq %r15, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
testl %ebp, %ebp
jle 0x2a10
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r15d, %r15d
movq (%r14), %rdx
leaq (%rdx,%r15), %rcx
addq $0x18, %rcx
addq %r15, %rdx
movq %r12, %rdi
callq 0x24da
movq %r14, %rdi
movq %r12, %rsi
callq 0x2d28
movq %r14, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2d28
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x29e5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x29fb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
addq $0x30, %r15
addl $0x2, %r13d
cmpl %ebp, %r13d
jl 0x29a0
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %r12
cmpq %r15, %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
je 0x2a6e
xorl %r15d, %r15d
xorl %r12d, %r12d
callq 0x1040
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x26df(%rip), %xmm0     # 0x5118
movsd 0x26cf(%rip), %xmm1     # 0x5110
ucomisd %xmm0, %xmm1
jb 0x2a52
movq (%r14), %rdi
addq %r15, %rdi
callq 0x18ca
incq %r12
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x18, %r15
cmpq %r12, %rax
ja 0x2a25
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f98
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::Shell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Shell::Shell(string diskName, int numberOfBlocks, int blockSize) : FileSystem(diskName, numberOfBlocks, blockSize)
{
    // Just Some Interesting Styling
    cout << "Interactive DOS Shell Version 0.1" << endl;
    cout << "Copyright 2016 by Ruben Castaneda" << endl;
    cout << "=================================" << endl;
    this->runShell();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4218
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x453c
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2749
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x7880(%rip), %r14      # 0x9fd0
leaq 0x48dd(%rip), %rsi      # 0x7034
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x784e(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x783a(%rip), %r14      # 0x9fd0
leaq 0x48b9(%rip), %rsi      # 0x7056
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x7808(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x77f4(%rip), %r14      # 0x9fd0
leaq 0x4895(%rip), %rsi      # 0x7078
movl $0x21, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x77c2(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2860
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2857
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x2857
movq %rax, %r14
movq %rbx, %rdi
callq 0x41b8
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::dir()
int Shell::dir(){
    vector<string> tmp = this->ls();

    for (int i = 0; i < tmp.size(); i++)
        cout << tmp[i] << " ";
    cout << endl;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x5ef0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2e86
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x718d(%rip), %rbx      # 0x9fd0
leaq 0x4271(%rip), %r14      # 0x70bb
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %rbx, %rdi
callq 0x21f0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
incq %r12
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %r12, %rcx
ja 0x2e4a
movq 0x7143(%rip), %rdi      # 0x9fd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq 0x7128(%rip), %rdi      # 0x9fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq -0x38(%rbp), %rdi
callq 0x25da
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2ed2
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x25da
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::add(string fileName)
{
    if (this->newFile(fileName)) {
        cout << "Would You Like To Add Data (y/n): ";
        string buffer;
        getline(cin, buffer);
        if (buffer == "y" || buffer == "Y")
            this->append(fileName);
    };
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r15, %rsi
callq 0x54cc
movl %eax, %r15d
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f3d
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
testl %r15d, %r15d
je 0x3017
movq 0x7083(%rip), %rdi      # 0x9fd0
leaq 0x4146(%rip), %rsi      # 0x709a
movl $0x22, %edx
callq 0x21f0
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x7067(%rip), %rdi      # 0x9fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %edx
movq 0x704c(%rip), %rdi      # 0x9fe0
leaq -0x40(%rbp), %rsi
callq 0x2320
leaq 0x41f7(%rip), %rsi      # 0x719b
leaq -0x40(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x2fc5
leaq 0x4105(%rip), %rsi      # 0x70bd
leaq -0x40(%rbp), %rdi
callq 0x2080
testl %eax, %eax
jne 0x3002
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x4218
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x3076
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3002
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x3017
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3058
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3058
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x306d
movq -0x70(%rbp), %rsi
jmp 0x3065
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x306d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::del(string fileName)
{
    int curBlock = this->getFirstBlock(fileName);

    // Return If File Does Not Exist
    if (curBlock == -1) {
        cout << "Cannot Find File To Remove" << endl;
        return 0;
    }

    // Remove All Blocks From File
    while ((curBlock = this->getFirstBlock(fileName)) > 0)
        this->delBlock(fileName, curBlock);

    // Remove File From Root
    this->rmFile(fileName);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r12, %rsi
callq 0x560e
movl %eax, %r12d
movq -0xb0(%rbp), %rdi
cmpq %r15, %rdi
je 0x37a5
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x21c0
cmpl $-0x1, %r12d
je 0x388e
leaq -0x40(%rbp), %r15
movq %r15, -0x30(%rbp)
movq %r15, -0x50(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r12, %rsi
callq 0x560e
movl %eax, %r13d
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x37f4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
testl %r13d, %r13d
jle 0x3843
leaq -0x60(%rbp), %r12
movq %r12, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x5b26
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
leaq -0x40(%rbp), %r15
je 0x37b7
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x37b7
leaq -0x80(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56dc
movq -0x90(%rbp), %rdi
movl $0x1, %ebx
cmpq %r15, %rdi
je 0x38d2
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x38d2
movq 0x673b(%rip), %rbx      # 0x9fd0
leaq 0x3823(%rip), %rsi      # 0x70bf
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x90(%rbp), %rdi
jmp 0x38fc
movq %rax, %rbx
movq -0xb0(%rbp), %rdi
movq %r15, -0x30(%rbp)
jmp 0x391b
movq %rax, %rbx
movq -0x70(%rbp), %rdi
movq %r12, -0x30(%rbp)
cmpq %r12, %rdi
jne 0x3920
jmp 0x392f
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x392f
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<string> splitString(string buffer)
{
    vector<string> split;

    size_t begin, end;
    begin = buffer.find_first_not_of(' ');
    end = buffer.find_first_of(' ', begin);

    while (begin != end) {
        split.push_back(buffer.substr(begin, end - begin));
        begin = buffer.find_first_not_of(' ', end);
        end = buffer.find_first_of(' ', begin);
    }

    return split;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x2240
cmpq %rax, %r13
je 0x4175
movq %rax, %r12
leaq -0x48(%rbp), %r15
movq %r12, %rcx
subq %r13, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x21e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x42b6
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x414a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0x2180
movq %rax, %r13
movq %r14, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x2240
movq %rax, %r12
cmpq %rax, %r13
jne 0x4112
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x41a8
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x41a8
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x25da
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::FileSystem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
FileSystem::FileSystem(string diskName, int numOfBlocks, int blockSize) : SDisk(diskName, numOfBlocks, blockSize)
{
	if (this->getStatusCode() <= 0)
		return;

	this->rootSize = this->getBlockSize() / 12;
	int byteReq = this->getNumberOfBlocks() * 6;
	this->fatSize = (byteReq / this->getBlockSize()) + (byteReq %
		this->getBlockSize() > 0);

	this->initRoot();
	this->initFat();

	this->fsSynch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4218
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r14d, %ecx
callq 0x62e4
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x459d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x78(%rbx)
movq %rbx, %rdi
callq 0x660c
testl %eax, %eax
jle 0x463d
movq %rbx, %rdi
callq 0x6602
cltq
imulq $0x2aaaaaab, %rax, %rax # imm = 0x2AAAAAAB
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
movl %eax, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x65f8
movl %eax, %r14d
movq %rbx, %rdi
callq 0x6602
movl %eax, %r15d
movq %rbx, %rdi
callq 0x6602
movl %eax, %ecx
addl %r14d, %r14d
leal (%r14,%r14,2), %esi
movl %esi, %eax
cltd
idivl %r15d
movl %eax, %edi
movl %esi, %eax
cltd
idivl %ecx
xorl %eax, %eax
testl %edx, %edx
setg %al
addl %edi, %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rdi
callq 0x46b8
movq %rbx, %rdi
callq 0x4a48
movq %rbx, %rdi
callq 0x4f1e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
jne 0x46a4
jmp 0x46b0
jmp 0x465c
movq %rax, %r14
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x4674
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
leaq 0x38(%rbx), %r15
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x468d
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x25da
movq (%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %r13
cmpq %rbx, %rdi
je 0x46b0
movq (%r13), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
vector<string> FileSystem::block(string buffer, int b)
{
	vector<string> blocks;
	int numberofblocks = 0;

	if (buffer.length() % b == 0)
	{
		numberofblocks = buffer.length()/b;
	} else {
		numberofblocks = buffer.length()/b +1;
	}

	string tempblock;
	for (int i = 0; i < numberofblocks; i++)
	{
		tempblock = buffer.substr(b*i, b);
		blocks.push_back(tempblock);
	}

	int lastblock = blocks.size() - 1;

	for (int i = blocks[lastblock].length(); i < b; i++)
	{
		blocks[lastblock] += "#";
	}

	return blocks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r14d
xorl %r12d, %r12d
movq %r12, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, -0x30(%rbp)
movups %xmm0, (%rdi)
movq %rsi, -0x58(%rbp)
movq 0x8(%rsi), %rax
movslq %edx, %r13
xorl %edx, %edx
divq %r13
movq %rax, %rbx
cmpq $0x1, %rdx
sbbl $-0x1, %ebx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq %r12, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq -0x58(%rbp), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x21e0
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x2220
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x5407
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5f88
addq %r13, %r12
decq %rbx
jne 0x53cc
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
shlq $0x1b, %rcx
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
addq %rcx, %r15
movq %r15, %rcx
sarq $0x1b, %rcx
subl 0x8(%rax,%rcx), %r14d
jle 0x546f
sarq $0x20, %r15
shlq $0x5, %r15
leaq 0x1d9d(%rip), %rbx      # 0x71f5
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x2330
decl %r14d
jne 0x5458
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5488
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x549f
jmp 0x549f
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x54bb
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rdi
callq 0x25da
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::newFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::newFile(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	// Returns If File Exists
	if (this->getFirstBlock(fileName) != -1)
		return 0;

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == ".....") {
			this->rootFileName[i] = fileName;
			this->rootFirstBlock[i] = 0;
			return this->fsSynch();
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
cmpq $0x6, %rdx
jb 0x552a
leaq -0x68(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x5526
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x8(%r14), %rdx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r15, %rsi
callq 0x560e
movl %eax, %r15d
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x5568
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
cmpl $-0x1, %r15d
je 0x557f
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rbx), %rdi
cmpq %rdi, 0x40(%rbx)
je 0x5570
xorl %r15d, %r15d
leaq 0x1c56(%rip), %r12      # 0x71e9
xorl %r13d, %r13d
addq %r15, %rdi
movq %r12, %rsi
callq 0x2080
testl %eax, %eax
je 0x55c4
incq %r13
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %r13, %rax
ja 0x5596
xorl %eax, %eax
jmp 0x5570
addq 0x38(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x20e0
movq 0x50(%rbx), %rax
movl $0x0, (%rax,%r13,4)
movq %rbx, %rdi
callq 0x4f1e
movl $0x1, %eax
jmp 0x5570
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x5606
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::getFirstBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::getFirstBlock(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == fileName)
			return this->rootFirstBlock[i];

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x6, 0x8(%rsi)
jb 0x5665
leaq -0x50(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x21e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5665
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x38(%rbx), %r13
movq 0x40(%rbx), %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %r13, %r15
je 0x56cd
movq %rbx, -0x30(%rbp)
sarq $0x5, %r15
movq 0x8(%r14), %r12
cmpq $0x1, %r15
adcq $0x0, %r15
addq $0x8, %r13
xorl %ebx, %ebx
cmpq %r12, (%r13)
jne 0x56af
testq %r12, %r12
je 0x56c2
movq (%r14), %rsi
movq -0x8(%r13), %rdi
movq %r12, %rdx
callq 0x21d0
testl %eax, %eax
je 0x56c2
incq %rbx
addq $0x20, %r13
cmpq %rbx, %r15
jne 0x5691
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x56cd
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movl (%rax,%rbx,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::rmFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::rmFile(string fileName)
{
	// Handles FileNames Greater Than 5 Chars
	if (fileName.length() > 5)
		fileName = fileName.substr(0, 5);

	int tmpFB = this->getFirstBlock(fileName);

	// Return 0 File Does Not Exist or File Contains Blocks
	if (tmpFB != 0)
		return 0;

	for (int i = 0; i < this->rootFileName.size(); i++)
		if (this->rootFileName[i] == fileName)
			this->rootFileName[i] = ".....";

	return this->fsSynch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x38(%rbp)
movq 0x8(%rsi), %rdx
cmpq $0x6, %rdx
movq %rsi, -0x30(%rbp)
jb 0x5740
leaq -0x80(%rbp), %r15
movl $0x5, %ecx
movq %r15, %rdi
movq %rsi, %rbx
xorl %edx, %edx
callq 0x21e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2220
movq (%r15), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x5738
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21c0
movq -0x30(%rbp), %rsi
movq 0x8(%rsi), %rdx
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rsi
addq %rsi, %rdx
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x4218
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x560e
movl %eax, %r15d
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x577e
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
testl %r15d, %r15d
jne 0x5828
movq -0x38(%rbp), %rax
movq 0x38(%rax), %r14
movq 0x40(%rax), %rdx
cmpq %r14, %rdx
movq -0x30(%rbp), %rcx
je 0x581a
xorl %r15d, %r15d
xorl %ebx, %ebx
movq 0x8(%r14,%r15), %r12
cmpq 0x8(%rcx), %r12
jne 0x5804
leaq (%r14,%r15), %r13
testq %r12, %r12
je 0x57da
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq (%r13), %rdi
movq %rdx, -0x40(%rbp)
movq %r12, %rdx
callq 0x21d0
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
testl %eax, %eax
jne 0x5804
movl $0x5, %r8d
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
leaq 0x19fa(%rip), %rcx      # 0x71e9
callq 0x22b0
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq 0x38(%rax), %r14
movq 0x40(%rax), %rdx
incq %rbx
movq %rdx, %rax
subq %r14, %rax
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rbx, %rax
ja 0x57a3
movq -0x38(%rbp), %rdi
callq 0x4f1e
movl $0x1, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x584f
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::delBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int FileSystem::delBlock(string fileName, int blockNum)
{
    int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Removing First Block Of File
    if (curBlock == blockNum) {
        for (int i = 0; i < this->rootFileName.size(); i++) {
            if (this->rootFileName[i] == fileName) {
                // Update Root [First Block]
                this->rootFirstBlock[i] = this->fat[blockNum];
                break;
            }
        }

        // Update + Sync, Fat And Root
        this->fat[blockNum] = this->fat[0];
        this->fat[0] = blockNum;
        return this->fsSynch();
    }

    // Block Is Not First Block
    for ( ; curBlock != 0; curBlock = this->fat[curBlock]) {
        if (this->fat[curBlock] == blockNum) {
            this->fat[curBlock] = this->fat[blockNum];

            // Sync Changes To Fat
            this->fat[blockNum] = this->fat[0];
            this->fat[0] = blockNum;
            return this->fsSynch();
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r14d
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x4218
movq %rbx, %rdi
movq %r12, %rsi
callq 0x560e
movl %eax, %r12d
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x5b85
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
cmpl $-0x1, %r12d
je 0x5c51
cmpl %r14d, %r12d
jne 0x5bf6
movq 0x38(%rbx), %r13
movq %rbx, -0x30(%rbp)
movq 0x40(%rbx), %rbx
subq %r13, %rbx
je 0x5c31
sarq $0x5, %rbx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r12
cmpq $0x1, %rbx
adcq $0x0, %rbx
addq $0x8, %r13
xorl %r15d, %r15d
cmpq %r12, (%r13)
jne 0x5be8
testq %r12, %r12
je 0x5c1b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%r13), %rdi
movq %r12, %rdx
callq 0x21d0
testl %eax, %eax
je 0x5c1b
incq %r15
addq $0x20, %r13
cmpq %r15, %rbx
jne 0x5bc6
jmp 0x5c31
movq 0x68(%rbx), %rcx
testl %r12d, %r12d
je 0x5c51
movslq %r12d, %rdx
movl (%rcx,%rdx,4), %r12d
cmpl %r14d, %r12d
jne 0x5bfa
movslq %r14d, %rax
movl (%rcx,%rax,4), %esi
movl %esi, (%rcx,%rdx,4)
movl (%rcx), %edx
movl %edx, (%rcx,%rax,4)
jmp 0x5c41
movslq %r14d, %rax
movq -0x30(%rbp), %rdx
movq 0x50(%rdx), %rcx
movq 0x68(%rdx), %rdx
movl (%rdx,%rax,4), %eax
movl %eax, (%rcx,%r15,4)
movq -0x30(%rbp), %rbx
movq 0x68(%rbx), %rcx
movl (%rcx), %eax
movslq %r14d, %rdx
movl %eax, (%rcx,%rdx,4)
movl %r14d, (%rcx)
movq %rbx, %rdi
callq 0x4f1e
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x5c78
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::readBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int FileSystem::readBlock(string fileName, int blockNum, string& buffer)
{
    int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Loop Through All Blocks Owned By File
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            return this->getBlock(blockNum, buffer);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rdi, %r15
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4218
movq %r15, %rdi
movq %r12, %rsi
callq 0x560e
movl %eax, %r12d
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5cde
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
leal 0x1(%r12), %ecx
cmpl $0x2, %ecx
jb 0x5d0f
movq 0x68(%r15), %rcx
cmpl %r14d, %r12d
je 0x5d01
movslq %r12d, %rdx
movl (%rcx,%rdx,4), %r12d
testl %r12d, %r12d
jne 0x5cee
jmp 0x5d0f
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x641e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x5d36
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::writeBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FileSystem::writeBlock(string fileName, int blockNum, string buffer)
{
    int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Loop Through File Blocks Looking For blockNum
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            return this->putBlock(blockNum, buffer);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, -0x30(%rbp)
movl %edx, %ebx
movq %rdi, %r14
leaq -0x60(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x4218
movq %r14, %rdi
movq %r12, %rsi
callq 0x560e
movl %eax, %r13d
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5d9c
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %r12d, %r12d
leal 0x1(%r13), %eax
cmpl $0x2, %eax
jae 0x5dba
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x68(%r14), %rax
cmpl %ebx, %r13d
je 0x5dd1
movslq %r13d, %rcx
movl (%rax,%rcx,4), %r13d
testl %r13d, %r13d
jne 0x5dbe
jmp 0x5da8
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x4218
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x650c
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x5da8
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x5da8
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x5e2a
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r15, %rdi
je 0x5e3a
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::nextBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int FileSystem::nextBlock(string fileName, int blockNum)
{
	int curBlock = this->getFirstBlock(fileName);

    // File Does Not Exist
    if (curBlock == -1)
        return 0;

    // Search File For Given Block Number
    for ( ; curBlock != 0; curBlock = this->fat[curBlock])
        if (curBlock == blockNum)
            // Returns The Block Number Of The Succeeding Block
            return this->fat[curBlock];

    // Handles blockNum = 0, etc.
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4218
movq %r14, %rdi
movq %r15, %rsi
callq 0x560e
movl %eax, %r15d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5e9b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
xorl %eax, %eax
leal 0x1(%r15), %ecx
cmpl $0x2, %ecx
jb 0x5ec3
movq 0x68(%r14), %rcx
cmpl %ebx, %r15d
je 0x5ebd
movslq %r15d, %rdx
movl (%rcx,%rdx,4), %r15d
testl %r15d, %r15d
jne 0x5eaa
jmp 0x5ec3
movslq %ebx, %rax
movl (%rcx,%rax,4), %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x5ee8
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/sdisk.cpp
// Function: SDisk::SDisk(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
SDisk::SDisk(string diskName, int numberOfBlocks, int blockSize)
{
	this->diskName = diskName;
	this->numberOfBlocks = numberOfBlocks;
	this->blockSize = blockSize;

	fstream fStream;

	fStream.open(this->diskName.c_str(), ios::in);
	if (fStream.fail()) {
		fStream.open(this->diskName.c_str(), ios::out);
		if (fStream.fail()) {
			this->statusCode = -1;
		} else {
			for (int x = 0; x < this->numberOfBlocks * this->blockSize; x++)
				fStream.put('#');
			this->statusCode = 1;
		}
	}
	fStream.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x20e0
movl %r15d, 0x20(%rbx)
movl %r14d, 0x24(%rbx)
leaq -0x238(%rbp), %rdi
callq 0x2200
movq (%rbx), %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x2190
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0x63c0
movq (%rbx), %rsi
leaq -0x238(%rbp), %rdi
movl $0x10, %edx
callq 0x2190
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testb $0x5, -0x218(%rbp,%rax)
jne 0x63bc
movl 0x24(%rbx), %eax
imull 0x20(%rbx), %eax
movl $0x1, %r15d
testl %eax, %eax
jle 0x63bc
xorl %r13d, %r13d
leaq -0x228(%rbp), %r14
movq %r14, %rdi
movl $0x23, %esi
callq 0x2030
incl %r13d
movl 0x24(%rbx), %eax
imull 0x20(%rbx), %eax
cmpl %eax, %r13d
jl 0x63a0
movl %r15d, 0x28(%rbx)
leaq -0x238(%rbp), %rdi
callq 0x2050
leaq -0x238(%rbp), %rdi
callq 0x2060
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63ec
movq %rax, %r14
jmp 0x6402
jmp 0x63f3
movq %rax, %r14
leaq -0x238(%rbp), %rdi
callq 0x2060
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6416
movq (%r12), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/sdisk.cpp
// Function: SDisk::getBlock(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int SDisk::getBlock(int blockNumber, string& dataOut)
{
	fstream sFile(this->diskName.c_str(), ios::in);

	if (sFile.fail())
		return 0;

	sFile.seekg(blockNumber * this->blockSize);
	dataOut = "";

	for (int x = 0; x < this->blockSize; x++)
		dataOut += sFile.get();

	sFile.close();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
movq (%rdi), %rsi
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
xorl %r15d, %r15d
testb $0x5, -0x210(%rbp,%rax)
jne 0x64d4
movslq 0x24(%r14), %rax
movslq %r12d, %rsi
imulq %rax, %rsi
leaq -0x230(%rbp), %rdi
xorl %edx, %edx
callq 0x2230
movq 0x8(%rbx), %rdx
leaq 0xc34(%rip), %rcx       # 0x70bc
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22b0
cmpl $0x0, 0x24(%r14)
jle 0x64c2
xorl %r12d, %r12d
leaq -0x230(%rbp), %r15
movq %r15, %rdi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2160
incl %r12d
cmpl 0x24(%r14), %r12d
jl 0x64a6
movl $0x1, %r15d
leaq -0x230(%rbp), %rdi
callq 0x2050
leaq -0x230(%rbp), %rdi
callq 0x2060
movl %r15d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x64f5
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/RC2K7[P]SDisk-FileSystem/sdisk.cpp
// Function: SDisk::putBlock(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int SDisk::putBlock(int blockNumber, string dataIn)
{
	fstream sFile(this->diskName.c_str(), ios::in | ios::out);

	if (sFile.fail())
		return 0;

	sFile.seekg(blockNumber * this->blockSize);

	for (int x = 0; x < dataIn.length() && x < this->blockSize; x++)
		sFile.put(dataIn[x]);

	sFile.close();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
movq (%rdi), %rsi
leaq -0x230(%rbp), %r15
movq %r15, %rdi
movl $0x18, %edx
callq 0x2250
movq (%r15), %rax
movq -0x18(%rax), %rax
xorl %r15d, %r15d
testb $0x5, -0x210(%rbp,%rax)
jne 0x65c0
movslq 0x24(%r14), %rax
movslq %r12d, %rsi
imulq %rax, %rsi
leaq -0x230(%rbp), %rdi
xorl %edx, %edx
callq 0x2230
cmpq $0x0, 0x8(%rbx)
je 0x65ae
cmpl $0x0, 0x24(%r14)
jle 0x65ae
movl $0x1, %r12d
leaq -0x220(%rbp), %r15
movq (%rbx), %rax
movsbl -0x1(%rax,%r12), %esi
movq %r15, %rdi
callq 0x2030
cmpq %r12, 0x8(%rbx)
jbe 0x65ae
leaq 0x1(%r12), %rax
movslq 0x24(%r14), %rcx
cmpq %rcx, %r12
movq %rax, %r12
jl 0x6586
movl $0x1, %r15d
leaq -0x230(%rbp), %rdi
callq 0x2050
leaq -0x230(%rbp), %rdi
callq 0x2060
movl %r15d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65e1
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/perf_simple_sst.cpp
// Function: test(int, int, bool)
void test(int n, int Q, bool recursive) {
    simple_static_search_tree tree(n, recursive);

    for (int i = 0; i < n; ++i) {
        tree.update(i, i);
    }

    for (int query = 0; query < Q; ++query)
    {   
        if (query % rand_reset_const == 0) {
            srand(query / rand_reset_const);
        }
        int type = rand() % 2;
        int index = rand() % n;
        if(type == 0) {
            tree.update(index, index);
        } else {
            if(tree.get(index) != index) {
                cout << "Fail: expected value " << index << " at index " << index << endl;
                return;
            }
        }
    }
    cout << "test(" << n << ", " << Q << "): OK" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x225e
testl %ebp, %ebp
jle 0x28f8
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
movl %r14d, %edx
callq 0x2464
incl %r14d
cmpl %r14d, %ebp
jne 0x28e2
testl %ebx, %ebx
jle 0x2969
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
movl %r13d, %edi
movl $0xd1b71759, %eax       # imm = 0xD1B71759
imulq %rax, %rdi
shrq $0x2d, %rdi
imull $0x2710, %edi, %eax     # imm = 0x2710
cmpl %r13d, %eax
jne 0x2924
callq 0x10f0
callq 0x1060
movl %eax, %r12d
callq 0x1060
cltd
idivl %ebp
movl %edx, %r15d
testb $0x1, %r12b
jne 0x294d
movq %r14, %rdi
movl %r15d, %esi
movl %r15d, %edx
callq 0x2464
jmp 0x2961
movq %r14, %rdi
movl %r15d, %esi
callq 0x248e
cmpl %r15d, %eax
jne 0x29f0
incl %r13d
cmpl %r13d, %ebx
jne 0x2904
movq 0x2660(%rip), %rdi      # 0x4fd0
leaq 0x813(%rip), %rsi       # 0x318a
movl $0x5, %edx
callq 0x1140
movq 0x2648(%rip), %rdi      # 0x4fd0
movl %ebp, %esi
callq 0x11c0
movq %rax, %r14
leaq 0x7f7(%rip), %rsi       # 0x3190
movl $0x2, %edx
movq %rax, %rdi
callq 0x1140
movq %r14, %rdi
movl %ebx, %esi
callq 0x11c0
movq %rax, %rbx
leaq 0x7d9(%rip), %rsi       # 0x3193
movl $0x5, %edx
movq %rax, %rdi
callq 0x1140
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
jmp 0x2a63
movq 0x25d9(%rip), %rdi      # 0x4fd0
leaq 0x76b(%rip), %rsi       # 0x3169
movl $0x15, %edx
callq 0x1140
movq 0x25c1(%rip), %rdi      # 0x4fd0
movl %r15d, %esi
callq 0x11c0
movq %rax, %rbx
leaq 0x75e(%rip), %rsi       # 0x317f
movl $0xa, %edx
movq %rax, %rdi
callq 0x1140
movq %rbx, %rdi
movl %r15d, %esi
callq 0x11c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10b0
leaq 0x8(%rsp), %rdi
callq 0x22c6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a82
jmp 0x2a82
jmp 0x2a82
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22c6
movq %rbx, %rdi
callq 0x11d0
// File: /workspace/github_cpp_makefile_star2_O3/m-wiesner[P]Jotto/Jotto.cpp
// Function: print_level()
void print_level()
{
    cout << "----------------------------------------";
    cout << "----------------------------------------" << endl;
    cout << "1 -- Random Guessing from dictionary." << endl;
    cout << "2 -- Random guessing removing impossible words"
         << endl <<  "     from the dictionary" << endl;
    cout << "3 -- Guessing word with maximum information from"
         << endl << "      the dictionary with impossible words removed." << endl;
    cout << "________________________________________";
    cout << "________________________________________" << endl;
 
    cout << "Choose the level (strategy) against which you wish to play: ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x5d80(%rip), %rbx      # 0x8fd0
leaq 0x2ff1(%rip), %r14      # 0x6248
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x2fcc(%rip), %rsi      # 0x6271
movl $0x25, %edx
movq %rbx, %rdi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x2fb7(%rip), %rsi      # 0x6297
movl $0x2e, %edx
movq %rbx, %rdi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rax, %r14
leaq 0x2fa8(%rip), %rsi      # 0x62c6
movl $0x18, %edx
movq %rax, %rdi
callq 0x2260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x2f86(%rip), %rsi      # 0x62df
movl $0x30, %edx
movq %rbx, %rdi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq %rax, %r14
leaq 0x2f79(%rip), %rsi      # 0x6310
movl $0x33, %edx
movq %rax, %rdi
callq 0x2260
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x2e00(%rip), %r14      # 0x61d2
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movl $0x28, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
leaq 0x2f24(%rip), %rsi      # 0x6344
movl $0x3c, %edx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/m-wiesner[P]Jotto/Jotto_utils.cpp
// Function: combinations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void _combinations (const std::string& word, int k, std::string out,
                   std::vector<std::string>& combs)
{
    typedef string::size_type sz;

    if (out.size() == k)
    {
        combs.push_back(out); 
        return;
    }

    for (sz i = 0; i < word.size(); ++i)
    {
        _combinations(word.substr(i + 1, word.size()), k, out + word[i], combs); 
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movl %esi, -0x2c(%rbp)
movslq %esi, %rax
cmpq %rax, 0x8(%rdx)
jne 0x3adb
movq %r13, %rdi
movq %rbx, %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3476
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x3b9f
movq %rdi, %rsi
xorl %r14d, %r14d
movq %rdi, -0x58(%rbp)
movq %r14, %r15
incq %r14
leaq -0x78(%rbp), %rdi
movq %r14, %rdx
movq %rsi, %r12
callq 0x2240
movq (%r12), %rax
movb (%rax,%r15), %r15b
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rbx), %rsi
movq %rbx, %r12
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x390c
movq -0x48(%rbp), %rsi
movsbl %r15b, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
leaq -0x78(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x3a9f
movq %r12, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3b75
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x3b8e
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x58(%rbp), %rsi
movq 0x8(%rsi), %rcx
cmpq %rcx, %r14
jb 0x3af2
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3bd1
jmp 0x3bb5
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3bd1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x3bea
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2220
movq %rbx, %rdi
callq 0x2320