LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/shell.cpp
// Function: Shell::type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Shell::type(string fileName)
{
    string fileBuffer = "";
    string blockBuffer = "";

    for ( int curBlock = getFirstBlock(fileName); curBlock != 0; curBlock = this->nextBlock(fileName, curBlock)) {
        this->readBlock(fileName, curBlock, blockBuffer);
        fileBuffer += blockBuffer;
    }

    fileBuffer = fileBuffer.substr(0, fileBuffer.find_first_of('#'));

    cout << fileBuffer << endl;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq 0x2e80(%rip), %rbx      # 0x60bc
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rdx
movq %rbx, %rsi
callq 0x258e
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq %rbx, %rsi
callq 0x258e
leaq -0xb0(%rbp), %rdi
movq %r14, %rsi
callq 0x2290
leaq -0xb0(%rbp), %r13
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x444a
movl %eax, %r15d
leaq -0xf0(%rbp), %r12
leaq -0xd0(%rbp), %rbx
movq %r13, %rdi
callq 0x20e0
testl %r15d, %r15d
je 0x32f6
movq %r12, %rdi
movq %r14, %rsi
callq 0x2290
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %r15d, %edx
leaq -0x70(%rbp), %r13
movq %r13, %rcx
callq 0x487c
movq %r12, %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x2380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2290
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x49b4
movl %eax, %r15d
movq %rbx, %r13
jmp 0x3292
leaq -0x50(%rbp), %rbx
pushq $0x23
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2270
leaq -0x90(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2200
leaq -0x90(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
movq %r14, %rdi
callq 0x20e0
movq 0x5c8c(%rip), %rdi      # 0x8fc8
movq %rbx, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
pushq $0x1
popq %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33a7
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x33a0
jmp 0x33a7
movq %rax, %rbx
jmp 0x33b3
jmp 0x33a7
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
jmp 0x33a0
movq %rax, %rbx
leaq -0xf0(%rbp), %rdi
callq 0x20e0
jmp 0x33aa
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
pushq $0x20
popq %r15
movq %rsi, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x21b0
movq %rax, %rbx
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2270
movq %rax, %r13
leaq -0x50(%rbp), %r12
movq %r13, %rcx
subq %rbx, %rcx
je 0x36dc
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2200
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x3722
movq %r12, %rdi
callq 0x20e0
movq %r14, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x21b0
movq %rax, %rbx
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x2270
movq %rax, %r13
jmp 0x368e
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3700
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x25fc
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %r14d, %ecx
callq 0x4edc
leaq -0x40(%rbp), %rdi
callq 0x20e0
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
andq $0x0, 0x78(%rbx)
movq %rbx, %rdi
callq 0x51be
testl %eax, %eax
jle 0x39dc
movq %rbx, %rdi
callq 0x51b4
pushq $0xc
popq %rcx
cltd
idivl %ecx
movl %eax, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x51aa
movl %eax, %r14d
movq %rbx, %rdi
callq 0x51b4
movl %eax, %r15d
movq %rbx, %rdi
callq 0x51b4
movl %eax, %ecx
imull $0x6, %r14d, %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 0x3a28
movq %rbx, %rdi
callq 0x3c34
movq %rbx, %rdi
callq 0x3f46
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rbx
jmp 0x3a17
jmp 0x39f3
movq %rax, %r14
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %r12
leaq 0x68(%rbx), %rdi
callq 0x2636
movq %r12, %rdi
callq 0x2636
movq %r15, %rdi
callq 0x25fc
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
andq $0x0, 0x10(%rdi)
movq %rsi, -0x40(%rbp)
movq 0x8(%rsi), %rax
movl %edx, -0x34(%rbp)
movslq %edx, %r12
xorl %edx, %edx
divq %r12
movq %rax, %r13
xorl %r14d, %r14d
cmpq $0x1, %rdx
sbbl $-0x1, %r13d
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %r13d, %r13d
cmovlel %r14d, %r13d
leaq -0x80(%rbp), %r15
leaq -0x60(%rbp), %rbx
subq $0x1, %r13
jb 0x42b2
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x4ae6
addq %r12, %r14
jmp 0x4276
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
shlq $0x1b, %rcx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
addq %rcx, %rdx
movq %rdx, %r14
sarq $0x20, %r14
sarq $0x1b, %rdx
movl 0x8(%rax,%rdx), %r15d
shlq $0x5, %r14
leaq 0x1f09(%rip), %rbx      # 0x61f5
cmpl -0x34(%rbp), %r15d
jge 0x4309
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq %r14, %rdi
movq %rbx, %rsi
callq 0x2360
incl %r15d
jmp 0x42ec
leaq -0x60(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4329
jmp 0x4329
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x25fc
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x6, 0x8(%rsi)
jb 0x438b
leaq -0x70(%rbp), %r15
pushq $0x5
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
movq %r14, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x444a
movl %eax, %r15d
leaq -0x50(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
cmpl $-0x1, %r15d
jne 0x4426
movq %r14, -0x30(%rbp)
pushq $-0x20
popq %r15
xorl %r13d, %r13d
movq %r13, %r12
movq 0x38(%rbx), %rax
movq 0x40(%rbx), %r14
subq %rax, %r14
sarq $0x5, %r14
cmpq %r13, %r14
jbe 0x441e
leaq (%r15,%rax), %rdi
addq $0x20, %rdi
leaq 0x1dff(%rip), %rsi      # 0x61e9
callq 0x3711
leaq 0x1(%r12), %r13
addq $0x20, %r15
testb %al, %al
je 0x43c4
addq 0x38(%rbx), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x2110
movq 0x50(%rbx), %rax
andl $0x0, -0x4(%rax,%r13,4)
movq %rbx, %rdi
callq 0x3f46
xorl %eax, %eax
cmpq %r12, %r14
seta %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x448f
leaq -0x48(%rbp), %r15
pushq $0x5
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
movq %r14, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
xorl %r12d, %r12d
pushq $-0x1
popq %r15
xorl %r13d, %r13d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x44cc
addq %r12, %rdi
movq %r14, %rsi
callq 0x4aba
incq %r13
addq $0x20, %r12
testb %al, %al
je 0x4499
movq 0x50(%rbx), %rax
movl -0x4(%rax,%r13,4), %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x6, 0x8(%rsi)
jb 0x4523
leaq -0x68(%rbp), %r15
pushq $0x5
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2200
movq %r14, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20e0
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2290
movq %rbx, %rdi
movq %r15, %rsi
callq 0x444a
movl %eax, %r15d
leaq -0x48(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
testl %r15d, %r15d
jne 0x45a3
xorl %r12d, %r12d
leaq 0x1c8f(%rip), %r15      # 0x61e9
xorl %r13d, %r13d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x4598
addq %r12, %rdi
movq %r14, %rsi
callq 0x4aba
testb %al, %al
je 0x458f
movq 0x38(%rbx), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x2370
incq %r13
addq $0x20, %r12
jmp 0x455d
movq %rbx, %rdi
callq 0x3f46
pushq $0x1
popq %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x2290
movq %rbx, %rdi
movq %r12, %rsi
callq 0x444a
movl %eax, %r12d
leaq -0x48(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
cmpl $-0x1, %r12d
je 0x4859
cmpl %r14d, %r12d
jne 0x481f
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x483f
addq %r13, %rdi
movq %r15, %rsi
callq 0x4aba
incq %r12
addq $0x20, %r13
testb %al, %al
je 0x47e0
movslq %r14d, %rax
movq 0x50(%rbx), %rdx
movq 0x68(%rbx), %rcx
movl (%rcx,%rax,4), %esi
movl %esi, -0x4(%rdx,%r12,4)
jmp 0x4846
movq 0x68(%rbx), %rcx
testl %r12d, %r12d
je 0x4859
movslq %r12d, %rdx
movl (%rcx,%rdx,4), %r12d
cmpl %r14d, %r12d
jne 0x4823
movslq %r14d, %rax
movl (%rcx,%rax,4), %esi
movl %esi, (%rcx,%rdx,4)
jmp 0x4846
movq 0x68(%rbx), %rcx
movslq %r14d, %rax
movl (%rcx), %edx
movl %edx, (%rcx,%rax,4)
movl %r14d, (%rcx)
movq %rbx, %rdi
callq 0x3f46
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movq %rdi, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x2290
movq %r15, %rdi
movq %r12, %rsi
callq 0x444a
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
cmpl $-0x1, %r12d
je 0x48e4
movq 0x68(%r15), %rcx
testl %r12d, %r12d
je 0x48e4
cmpl %r14d, %r12d
je 0x48d6
movslq %r12d, %rdx
movl (%rcx,%rdx,4), %r12d
jmp 0x48c3
movq %r15, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x4ff8
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x2290
movq %r14, %rdi
movq %r12, %rsi
callq 0x444a
movl %eax, %r15d
leaq -0x70(%rbp), %rdi
callq 0x20e0
xorl %r13d, %r13d
cmpl $-0x1, %r15d
je 0x498c
movq 0x68(%r14), %rax
testl %r15d, %r15d
je 0x498c
cmpl %ebx, %r15d
je 0x4963
movslq %r15d, %rcx
movl (%rax,%rcx,4), %r15d
jmp 0x4950
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq -0x30(%rbp), %rsi
callq 0x2290
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x50d6
movl %eax, %r13d
leaq -0x50(%rbp), %rdi
callq 0x20e0
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49a0
movq %rax, %rbx
movq %r12, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r15
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x2290
movq %r15, %rdi
movq %r14, %rsi
callq 0x444a
movl %eax, %r14d
leaq -0x38(%rbp), %rdi
callq 0x20e0
xorl %eax, %eax
cmpl $-0x1, %r14d
je 0x4a0e
movq 0x68(%r15), %rcx
testl %r14d, %r14d
je 0x4a0e
cmpl %ebx, %r14d
je 0x4a08
movslq %r14d, %rdx
movl (%rcx,%rdx,4), %r14d
jmp 0x49f5
movslq %ebx, %rax
movl (%rcx,%rax,4), %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/RC2K7[P]SDisk-FileSystem/filesystem.cpp
// Function: FileSystem::ls[abi:cxx11]()
vector<string> FileSystem::ls()
{
    vector<string> files;

    // Loop Through All FileNames And Get All Allocated Files
    for (int i = 0; i < this->rootFileName.size(); i++)
        if (this->rootFileName[i] != ".....")
            files.push_back(this->rootFileName[i]);

    return files;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r12d, %r12d
leaq 0x1792(%rip), %r15      # 0x61e9
xorl %r13d, %r13d
movq 0x38(%r14), %rdi
movq 0x40(%r14), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x4a95
addq %r12, %rdi
movq %r15, %rsi
callq 0x4b42
testb %al, %al
je 0x4a8c
movq 0x38(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x4ae6
incq %r13
addq $0x20, %r12
jmp 0x4a5a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x25fc
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x2110
movl %r15d, 0x20(%rbx)
movl %r14d, 0x24(%rbx)
leaq -0x238(%rbp), %rdi
callq 0x2220
movq (%rbx), %rsi
leaq -0x238(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x21c0
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0x4f78
movq (%rbx), %rsi
leaq -0x238(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x21c0
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0x4fa2
pushq $-0x1
popq %r12
movl %r12d, 0x28(%rbx)
leaq -0x238(%rbp), %rdi
callq 0x2050
leaq -0x238(%rbp), %rdi
callq 0x2070
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
leaq -0x228(%rbp), %r14
pushq $0x1
popq %r12
pushq $0x23
popq %r15
movl 0x24(%rbx), %eax
imull 0x20(%rbx), %eax
cmpl %eax, %r13d
jge 0x4f74
movq %r14, %rdi
movl %r15d, %esi
callq 0x2030
incl %r13d
jmp 0x4fb4
jmp 0x4fd2
movq %rax, %r14
jmp 0x4fe8
jmp 0x4fd9
movq %rax, %r14
leaq -0x238(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdi, %r14
movq (%rdi), %rsi
leaq -0x230(%rbp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
callq 0x2280
movq (%r12), %rax
movq -0x18(%rax), %rax
xorl %r12d, %r12d
testb $0x5, -0x210(%rbp,%rax)
jne 0x509d
movslq 0x24(%r14), %rax
movslq %r15d, %rsi
imulq %rax, %rsi
leaq -0x230(%rbp), %rdi
xorl %edx, %edx
callq 0x2250
leaq 0x105f(%rip), %rsi      # 0x60bc
movq %rbx, %rdi
callq 0x2370
xorl %r12d, %r12d
leaq -0x230(%rbp), %r15
cmpl 0x24(%r14), %r12d
jge 0x508d
movq %r15, %rdi
callq 0x2230
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2180
incl %r12d
jmp 0x506f
leaq -0x230(%rbp), %rdi
callq 0x2050
pushq $0x1
popq %r12
leaq -0x230(%rbp), %rdi
callq 0x2070
movl %r12d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50be
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15d
movq %rdi, %r14
movq (%rdi), %rsi
leaq -0x230(%rbp), %r12
pushq $0x18
popq %rdx
movq %r12, %rdi
callq 0x2280
movq (%r12), %rax
movq -0x18(%rax), %rax
xorl %r12d, %r12d
testb $0x5, -0x210(%rbp,%rax)
jne 0x5172
movslq 0x24(%r14), %rax
movslq %r15d, %rsi
imulq %rax, %rsi
leaq -0x230(%rbp), %rdi
xorl %edx, %edx
callq 0x2250
leaq -0x220(%rbp), %r15
xorl %r12d, %r12d
cmpq %r12, 0x8(%rbx)
jbe 0x5162
movslq 0x24(%r14), %rax
cmpq %rax, %r12
jge 0x5162
movq (%rbx), %rax
movsbl (%rax,%r12), %esi
movq %r15, %rdi
callq 0x2030
incq %r12
jmp 0x513e
leaq -0x230(%rbp), %rdi
callq 0x2050
pushq $0x1
popq %r12
leaq -0x230(%rbp), %rdi
callq 0x2070
movl %r12d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5193
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x4(%rsp)
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f72
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %ebx
cmovgl %ebp, %ebx
cmpl %r15d, %ebx
je 0x2794
movq %r14, %rdi
movl %r15d, %esi
movl %r15d, %edx
callq 0x2140
incl %r15d
jmp 0x277c
xorl %r14d, %r14d
movl 0x4(%rsp), %eax
testl %eax, %eax
movl $0x0, %ebx
cmovgl %eax, %ebx
movl $0x2710, %r15d          # imm = 0x2710
movl %r14d, %eax
xorl %edx, %edx
divl %r15d
cmpl %r14d, %ebx
je 0x2814
imull $0x2710, %eax, %ecx     # imm = 0x2710
movl %r14d, %eax
xorl %edx, %edx
divl %r15d
cmpl %r14d, %ecx
jne 0x27d2
movl %eax, %edi
callq 0x10f0
callq 0x1050
movl %eax, %r13d
callq 0x1050
cltd
idivl %ebp
movl %edx, %r12d
testb $0x1, %r13b
jne 0x27fd
leaq 0x8(%rsp), %rdi
movl %r12d, %esi
movl %r12d, %edx
callq 0x2140
jmp 0x280f
leaq 0x8(%rsp), %rdi
movl %r12d, %esi
callq 0x2166
cmpl %r12d, %eax
jne 0x2865
incl %r14d
jmp 0x27ab
movq 0x37b5(%rip), %rdi      # 0x5fd0
leaq 0x968(%rip), %rsi       # 0x318a
callq 0x1100
movq %rax, %rdi
movl %ebp, %esi
callq 0x11b0
leaq 0x958(%rip), %rsi       # 0x3190
movq %rax, %rdi
callq 0x1100
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x11b0
leaq 0x940(%rip), %rsi       # 0x3193
movq %rax, %rdi
callq 0x1100
movq %rax, %rdi
callq 0x1090
jmp 0x28a5
movq 0x3764(%rip), %rdi      # 0x5fd0
leaq 0x8f6(%rip), %rsi       # 0x3169
callq 0x1100
movq %rax, %rdi
movl %r12d, %esi
callq 0x11b0
leaq 0x8f5(%rip), %rsi       # 0x317f
movq %rax, %rdi
callq 0x1100
movq %rax, %rdi
movl %r12d, %esi
callq 0x11b0
movq %rax, %rdi
callq 0x1090
leaq 0x8(%rsp), %rdi
callq 0x1fb4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28c4
jmp 0x28c4
jmp 0x28c4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fb4
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x71e5(%rip), %rbx      # 0x9fd0
leaq 0x3456(%rip), %r14      # 0x6248
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x345a(%rip), %rsi      # 0x6271
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x3469(%rip), %rsi      # 0x6297
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x3481(%rip), %rsi      # 0x62c6
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x3483(%rip), %rsi      # 0x62df
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x349d(%rip), %rsi      # 0x6310
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x3348(%rip), %r14      # 0x61d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x3495(%rip), %rsi      # 0x6344
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, -0x2c(%rbp)
movslq %esi, %rax
cmpq %rax, 0x8(%rdx)
jne 0x34e6
movq %rcx, %rdi
movq %rdx, %rsi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f60
movq %rdi, %r12
movq %rcx, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
xorl %ebx, %ebx
leaq -0x80(%rbp), %r13
leaq -0x60(%rbp), %r14
movq 0x8(%r12), %rcx
cmpq %rcx, %rbx
jae 0x3552
leaq 0x1(%rbx), %r15
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2260
movq (%r12), %rax
movsbl (%rax,%rbx), %edx
movq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0x360a
movq %r13, %rdi
movl -0x2c(%rbp), %esi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
callq 0x34b0
movq %r14, %rdi
callq 0x2100
movq %r13, %rdi
callq 0x2100
movq %r15, %rbx
jmp 0x34fb
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2100
jmp 0x3572
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/Jotto_utils.cpp
// Function: score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int score(string w1, string w2)
{
     
    sort(w1.begin(), w1.end());
    sort(w2.begin(), w2.end());

    string intersection;
    set_intersection(w1.begin(), w1.end(),
                     w2.begin(), w2.end(), back_inserter(intersection));
  
    return intersection.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
callq 0x3645
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
callq 0x3645
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
addq %rdx, %rcx
leaq -0x30(%rbp), %r8
callq 0x3a73
leaq -0x30(%rbp), %rdi
movl 0x8(%rdi), %ebx
callq 0x2100
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/Guesser.cpp
// Function: Guesser::set_wordlist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int Guesser::set_wordlist(const string& path_to_wordlist)
{
    ifstream infile(path_to_wordlist.c_str());
    string line;

    if (infile.is_open())
    {
        while(getline(infile, line))
        {
            assert(line.size() == JOTTO_LENGTH);
            wordlist.push_back(line);
        }
        infile.close();
        return 0;
    }
    else
    {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x240(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2390
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1c8(%rbp), %rdi
callq 0x2080
testb %al, %al
je 0x3c03
addq $0x40, %rbx
leaq -0x240(%rbp), %r14
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3c08
cmpq $0x5, -0x30(%rbp)
jne 0x3c3b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ee4
jmp 0x3bd6
pushq $0x1
popq %rbx
jmp 0x3c16
xorl %ebx, %ebx
leaq -0x240(%rbp), %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x2100
leaq -0x240(%rbp), %rdi
callq 0x2090
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2783(%rip), %rdi      # 0x63c5
leaq 0x2798(%rip), %rsi      # 0x63e1
leaq 0x279d(%rip), %rcx      # 0x63ed
pushq $0x23
popq %rdx
callq 0x2160
jmp 0x3c5a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2100
leaq -0x240(%rbp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/Guesser.cpp
// Function: Guesser::guess[abi:cxx11]() const
string Guesser::guess() const
{
    int numwords = wordlist.size(); 
    
    // Random word
    list<string>::const_iterator itr = wordlist.begin();
    int stop = rand() % numwords;
    for(int i = 0; i < stop; ++i)
    {
        ++itr; 
    }

    return *itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rsi), %r15d
movq 0x40(%rsi), %r14
callq 0x20a0
cltd
idivl %r15d
xorl %eax, %eax
testl %edx, %edx
cmovgl %edx, %eax
subl $0x1, %eax
jb 0x3d37
movq (%r14), %r14
jmp 0x3d2d
addq $0x10, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/Guesser.cpp
// Function: Guesser::print_wordlist(int) const
void Guesser::print_wordlist (int max_rows) const
{
    int num_rows = 0;
    list<string>::size_type numwords = get_wordlist_size();

    // Print first max_rows number of words  
    cout << " --------------------------------------- " << endl;
    for (list<string>::const_iterator it = wordlist.begin();
         (it != wordlist.end()) && (num_rows < max_rows); ++it)
    {
        cout << *it << endl;
        ++num_rows;
    }


    // Print last max_rows number of words
    if ((int)numwords > 2 * max_rows)
    {
        cout << "..." << endl;
        cout << "... " << numwords << " words ..." << endl;
        cout << "..." << endl; 
    }
}

// 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 0x50(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x6253(%rip), %r12      # 0x9fd0
leaq 0x2693(%rip), %rsi      # 0x6417
movq %r12, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
addq $0x40, %rbx
xorl %r13d, %r13d
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x3dc4
cmpl %r14d, %r13d
jge 0x3dc4
leaq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x2110
incl %r13d
jmp 0x3d9e
addl %r14d, %r14d
movq -0x30(%rbp), %rbx
cmpl %ebx, %r14d
jge 0x3e43
movq 0x61f9(%rip), %r14      # 0x9fd0
leaq 0x23be(%rip), %r15      # 0x619c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x2649(%rip), %rsi      # 0x6441
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2170
leaq 0x2634(%rip), %rsi      # 0x6446
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/Guesser.cpp
// Function: Guesser::print_guesses() const
void Guesser::print_guesses() const
{
    cout << " -------- Guesses ------ " << player << " ----------------- " << endl;
    for (vector< pair<string, int> >::const_iterator it = guesses.begin();
         it != guesses.end(); ++it)
    {
        cout << it->first << " :: " << it->second << endl;
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x6169(%rip), %r14      # 0x9fd0
leaq 0x25e3(%rip), %rsi      # 0x6451
movq %r14, %rdi
callq 0x2230
leaq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2200
leaq 0x25e2(%rip), %rsi      # 0x646b
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
movq 0x28(%rbx), %r15
leaq 0x25db(%rip), %r12      # 0x647f
cmpq 0x30(%rbx), %r15
je 0x3eda
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x2350
movq %rax, %rdi
callq 0x2110
addq $0x28, %r15
jmp 0x3ea4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/ManualGuesser.cpp
// Function: ManualGuesser::random_guess[abi:cxx11]() const
string ManualGuesser::random_guess() const
{
    string guess;
    do
    {
        if(cin >> guess)
        {
            if (find(wordlist.begin(), wordlist.end(), guess) == wordlist.end())
            {
                cout << "Bad Input: That word is not in the dictionary." << endl; 
                cout << "Enter a different word: ";
            }
            else
            {
                break;
            }
        }
        else
        {
            cout << "\rThanks for playing!" << endl;
            exit(0);
        }
    }while (true);

    return guess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
addq $0x40, %r14
movq 0x5cbd(%rip), %r15      # 0x9fe0
movq 0x5ca6(%rip), %r12      # 0x9fd0
leaq 0x21af(%rip), %r13      # 0x64e0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4393
movq (%r14), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x442d
cmpq %r14, %rax
jne 0x4381
movq %r12, %rdi
leaq 0x214a(%rip), %rsi      # 0x64b1
callq 0x2230
movq %rax, %rdi
callq 0x2110
movq %r12, %rdi
movq %r13, %rsi
callq 0x2230
jmp 0x4331
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5c36(%rip), %rdi      # 0x9fd0
leaq 0x2158(%rip), %rsi      # 0x64f9
callq 0x2230
movq %rax, %rdi
callq 0x2110
xorl %edi, %edi
callq 0x22a0
jmp 0x43b9
jmp 0x43b9
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/RandomGuesser.cpp
// Function: RandomGuesser::update()
void RandomGuesser::update()
{
    // Score all words in the dictionary against w and remove
    // all entries that have a different score
    list<string>::iterator it = wordlist.begin();
    while (it != wordlist.end())
    {
        if (compare_words(*it))
        {
            it = wordlist.erase(it);
        }
        else
        {
            ++it;
        }
    }
    
    // Takes care of removing words that are only permuations of letters
    list<string>::iterator last_it = find(wordlist.begin(), wordlist.end(), guesses.back().first); 
    if (last_it != wordlist.end())
    {
        wordlist.erase(last_it);
    }

    if (wordlist.empty())
    {
        cout << "Error: No more possible words in the dictionary." << endl;
        cout << "Either you discovered a bug in the program, or used";
        cout << " an invalid word" << endl;
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x40(%rdi), %rbx
movq 0x40(%rdi), %r15
cmpq %rbx, %r15
je 0x4507
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x4588
testb %al, %al
je 0x4502
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4630
movq %rax, %r15
jmp 0x44dd
movq (%r15), %r15
jmp 0x44dd
movq 0x30(%r14), %rdx
movq 0x40(%r14), %rdi
addq $-0x28, %rdx
movq %rbx, %rsi
callq 0x4677
cmpq %rbx, %rax
je 0x452b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4630
cmpq %rbx, (%rbx)
je 0x453b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5a8e(%rip), %rbx      # 0x9fd0
leaq 0x1fd5(%rip), %rsi      # 0x651e
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
leaq 0x1fef(%rip), %rsi      # 0x654f
movq %rbx, %rdi
callq 0x2230
leaq 0x2014(%rip), %rsi      # 0x6583
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2110
pushq $0x1
popq %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/MaxinfoGuesser.cpp
// Function: MaxinfoGuesser::guess[abi:cxx11]() const
string MaxinfoGuesser::guess() const
{
    string best_word = RandomGuesser::guess();
   
    int numwords = get_wordlist_size();
    double max_info = 0.0;
     
    int i = 0;
    for(list<string>::const_iterator it = wordlist.begin();
        it != wordlist.end(); ++it)
    {
        if ((rand() % numwords) < (numwords * SAMPLING_PROB)) 
        {
            double w_info = calc_information(*it);
            if(w_info > max_info)
            {
                max_info = w_info;
                best_word = *it; 
            }
            ++i;
        }
    }
    return best_word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
callq 0x3d08
movq %r14, %rdi
callq 0x3cfe
movq %rax, %r15
leaq 0x40(%r14), %rbx
cvtsi2sd %r15d, %xmm0
mulsd 0x1e83(%rip), %xmm0     # 0x65a8
movsd %xmm0, -0x40(%rbp)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x4780
callq 0x20a0
cltd
idivl %r15d
cvtsi2sd %edx, %xmm0
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x4736
leaq 0x10(%r13), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x47ac
ucomisd -0x38(%rbp), %xmm0
jbe 0x4736
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movsd %xmm0, -0x38(%rbp)
callq 0x2130
jmp 0x4736
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4797
jmp 0x4797
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2360
nop
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/MaxinfoGuesser.cpp
// Function: MaxinfoGuesser::calc_information(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
double MaxinfoGuesser::calc_information (const string& s) const
{
    double count_of_counts [JOTTO_LENGTH + 1];
    //for w in wordlist
    for (list<string>::const_iterator it = wordlist.begin();
         it != wordlist.end(); ++it)
    {
        ++count_of_counts[score(s, *it)];
    }
    
    double information = 0.0;
    // Calculate entropy (bits of information)
    for (int i = 0; i < JOTTO_LENGTH + 1; ++i)
    {
        double frac = count_of_counts[i] / wordlist.size();
        information += -1 * frac * my_log2(frac);
    } 
    return information; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq 0x40(%rdi), %rbx
leaq -0xc0(%rbp), %r15
leaq -0xa0(%rbp), %r12
movq %rbx, %r13
movq (%r13), %r13
cmpq %rbx, %r13
je 0x482f
movq %r15, %rdi
movq %r14, %rsi
callq 0x22f0
leaq 0x10(%r13), %rsi
movq %r12, %rdi
callq 0x22f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x3583
cltq
movsd -0x80(%rbp,%rax,8), %xmm0
addsd 0x1d99(%rip), %xmm0     # 0x65b0
movsd %xmm0, -0x80(%rbp,%rax,8)
movq %r12, %rdi
callq 0x2100
movq %r15, %rdi
callq 0x2100
jmp 0x47dc
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
leaq -0x48(%rbp), %r14
movq -0x38(%rbp), %r15
cmpq $0x6, %rbx
je 0x48a2
movsd -0x80(%rbp,%rbx,8), %xmm2
movsd %xmm0, -0x30(%rbp)
movsd 0x50(%r15), %xmm0
unpcklps 0x1d65(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1d6d(%rip), %xmm0     # 0x65d0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm2
movsd %xmm2, -0x40(%rbp)
movsd %xmm2, -0x48(%rbp)
movq %r14, %rdi
callq 0x48dc
mulsd -0x40(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
incq %rbx
jmp 0x483d
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x48c8
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2100
leaq -0xc0(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2360
// File: /workspace/github_cpp_makefile_star2_O2/m-wiesner[P]Jotto/ScoreKeeper.cpp
// Function: ScoreKeeper::ScoreKeeper(Guesser*, Guesser*)
ScoreKeeper::ScoreKeeper(Guesser *g1, Guesser *g2)
{
    string n1 = g1->get_player();
    string n2 = g2->get_player();
    
    codewords[n1] = solicit_codeword(g2); // get codeword g1 tries to guess
    codewords[n2] = solicit_codeword(g1); // get codeword g2 tries to guess
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
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 -0x78(%rbp), %rdi
callq 0x3ce2
leaq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x3ce2
movq (%r15), %rax
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ce6
leaq -0x38(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x22b0
movq %r15, %rdi
callq 0x2100
movq (%r14), %rax
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq *0x8(%rax)
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ce6
leaq -0x38(%rbp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x22b0
movq %rbx, %rdi
callq 0x2100
leaq -0x58(%rbp), %rdi
callq 0x2100
leaq -0x78(%rbp), %rdi
callq 0x2100
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49ba
jmp 0x49c8
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2100
jmp 0x49cb
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x2100
jmp 0x49d9
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x30ac
movq %r14, %rdi
callq 0x2360
movq %rax, %r14
jmp 0x49e2
nop