LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
movq %rdi, %rax
movq %rax, -0x258(%rbp)
callq 0x33e0
movq -0x250(%rbp), %rdi
movq -0x248(%rbp), %rsi
callq 0x3050
jmp 0x96af
movq -0x258(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x24(%rax)
leaq -0x238(%rbp), %rdi
callq 0x3340
jmp 0x96d0
movq -0x258(%rbp), %rdi
callq 0x30f0
movq %rax, %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x3250
jmp 0x96f2
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x238(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x259(%rbp)
jmp 0x9712
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x9721
jmp 0x9805
movq -0x258(%rbp), %rdi
callq 0x30f0
movq %rax, %rsi
leaq -0x238(%rbp), %rdi
movl $0x10, %edx
callq 0x3250
jmp 0x9743
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x238(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x25a(%rbp)
jmp 0x9763
movb -0x25a(%rbp), %al
testb $0x1, %al
jne 0x976f
jmp 0x97ad
movq -0x258(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0x9803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x9828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x30a0
jmp 0x9828
movl $0x0, -0x23c(%rbp)
movq -0x258(%rbp), %rdx
movl -0x23c(%rbp), %eax
movl 0x20(%rdx), %ecx
imull 0x24(%rdx), %ecx
cmpl %ecx, %eax
jge 0x97f5
leaq -0x228(%rbp), %rdi
movl $0x23, %esi
callq 0x3040
jmp 0x97e2
jmp 0x97e4
movl -0x23c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x23c(%rbp)
jmp 0x97b7
movq -0x258(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0x9805
leaq -0x238(%rbp), %rdi
callq 0x3070
jmp 0x9813
leaq -0x238(%rbp), %rdi
callq 0x30a0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x3170
movq -0x20(%rbp), %rdi
callq 0x3470
nopl (%rax)
// File: 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
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x30f0
movq %rax, %rsi
leaq -0x230(%rbp), %rdi
movl $0x8, %edx
callq 0x33c0
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x230(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x255(%rbp)
jmp 0x989a
movb -0x255(%rbp), %al
testb $0x1, %al
jne 0x98a6
jmp 0x98df
movl $0x0, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
jmp 0x99a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x30a0
jmp 0x99bc
movq -0x260(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x24(%rcx), %ecx
imull %ecx, %eax
movslq %eax, %rsi
leaq -0x250(%rbp), %rdi
callq 0x9c50
jmp 0x9900
movq -0x250(%rbp), %rsi
movq -0x248(%rbp), %rdx
leaq -0x230(%rbp), %rdi
callq 0x3390
jmp 0x991c
movq -0x20(%rbp), %rdi
leaq 0x795(%rip), %rsi       # 0xa0bc
callq 0x33d0
jmp 0x992e
movl $0x0, -0x254(%rbp)
movq -0x260(%rbp), %rcx
movl -0x254(%rbp), %eax
cmpl 0x24(%rcx), %eax
jge 0x9985
leaq -0x230(%rbp), %rdi
callq 0x3350
movl %eax, -0x264(%rbp)
jmp 0x995e
movl -0x264(%rbp), %eax
movq -0x20(%rbp), %rdi
movsbl %al, %esi
callq 0x3180
jmp 0x9972
jmp 0x9974
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x9938
leaq -0x230(%rbp), %rdi
callq 0x3070
jmp 0x9993
movl $0x1, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x30a0
movl -0x4(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x3470
nopl (%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdx, -0x270(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x30f0
movq %rax, -0x260(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x9c90
movq -0x260(%rbp), %rsi
movl %eax, %edx
leaq -0x230(%rbp), %rdi
callq 0x33c0
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x230(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x255(%rbp)
jmp 0x9a48
movb -0x255(%rbp), %al
testb $0x1, %al
jne 0x9a54
jmp 0x9a8d
movl $0x0, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
jmp 0x9ba1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x30a0
jmp 0x9bb9
movq -0x268(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x24(%rcx), %ecx
imull %ecx, %eax
movslq %eax, %rsi
leaq -0x250(%rbp), %rdi
callq 0x9c50
jmp 0x9aae
movq -0x250(%rbp), %rsi
movq -0x248(%rbp), %rdx
leaq -0x230(%rbp), %rdi
callq 0x3390
jmp 0x9aca
movl $0x0, -0x254(%rbp)
movq -0x270(%rbp), %rdi
movslq -0x254(%rbp), %rax
movq %rax, -0x280(%rbp)
callq 0x3410
movq -0x280(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x271(%rbp)
jae 0x9b1e
movq -0x268(%rbp), %rcx
movl -0x254(%rbp), %eax
cmpl 0x24(%rcx), %eax
setl %al
movb %al, -0x271(%rbp)
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x9b2a
jmp 0x9b82
movq -0x270(%rbp), %rdi
leaq -0x220(%rbp), %rax
movq %rax, -0x290(%rbp)
movslq -0x254(%rbp), %rsi
callq 0x34c0
movq %rax, -0x288(%rbp)
jmp 0x9b54
movq -0x290(%rbp), %rdi
movq -0x288(%rbp), %rax
movsbl (%rax), %esi
callq 0x3040
jmp 0x9b6c
jmp 0x9b6e
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
jmp 0x9ad4
leaq -0x230(%rbp), %rdi
callq 0x3070
jmp 0x9b90
movl $0x1, -0x4(%rbp)
movl $0x1, -0x240(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x30a0
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: 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
movq 0xf92d(%rip), %rdi      # 0x13fc8
leaq 0x8ba6(%rip), %rsi      # 0xd248
callq 0x32a0
movq 0xf91a(%rip), %rdi      # 0x13fc8
leaq 0x8b93(%rip), %rsi      # 0xd248
callq 0x32a0
movq %rax, %rdi
movq 0xf8f4(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xf8f8(%rip), %rdi      # 0x13fc8
leaq 0x8b9a(%rip), %rsi      # 0xd271
callq 0x32a0
movq %rax, %rdi
movq 0xf8d2(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xf8d6(%rip), %rdi      # 0x13fc8
leaq 0x8b9e(%rip), %rsi      # 0xd297
callq 0x32a0
movq %rax, %rdi
movq 0xf8b0(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq %rax, %rdi
leaq 0x8baf(%rip), %rsi      # 0xd2c6
callq 0x32a0
movq %rax, %rdi
movq 0xf892(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xf896(%rip), %rdi      # 0x13fc8
leaq 0x8ba6(%rip), %rsi      # 0xd2df
callq 0x32a0
movq %rax, %rdi
movq 0xf870(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq %rax, %rdi
leaq 0x8bb9(%rip), %rsi      # 0xd310
callq 0x32a0
movq %rax, %rdi
movq 0xf852(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xf856(%rip), %rdi      # 0x13fc8
leaq 0x8a59(%rip), %rsi      # 0xd1d2
callq 0x32a0
movq 0xf843(%rip), %rdi      # 0x13fc8
leaq 0x8a46(%rip), %rsi      # 0xd1d2
callq 0x32a0
movq %rax, %rdi
movq 0xf81d(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xf821(%rip), %rdi      # 0x13fc8
leaq 0x8b96(%rip), %rsi      # 0xd344
callq 0x32a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x31e0
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0x632f
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x4940
jmp 0x6428
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31e0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x6428
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x28(%rbp), %rax
incq %rax
movq %rax, -0xa0(%rbp)
callq 0x31e0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
leaq -0x48(%rbp), %rdi
callq 0x32d0
movl -0xc(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3340
movq -0x80(%rbp), %rsi
movsbl (%rax), %edx
leaq -0x68(%rbp), %rdi
callq 0x65a0
jmp 0x63be
movl -0x94(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x62e0
jmp 0x63d7
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x48(%rbp), %rdi
callq 0x3190
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6337
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x641d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x48(%rbp), %rdi
callq 0x3190
jmp 0x6431
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rsi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3250
movq -0xb0(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3160
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6620
movq -0xa8(%rbp), %rdi
callq 0x3250
movq -0xa8(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x3160
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6620
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x33e0
movq -0xb0(%rbp), %rdi
callq 0x3250
movq -0xb0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x3160
movq -0xa8(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x3250
movq -0xa8(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x3160
movq -0xa0(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x66d0
movq %rax, -0x98(%rbp)
jmp 0x6519
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rcx
movq -0x78(%rbp), %r8
callq 0x6660
movq %rax, -0xb8(%rbp)
jmp 0x6546
movq -0xb8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31e0
movl %eax, -0xbc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3190
movl -0xbc(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3190
movq -0x80(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: 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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x268(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x260(%rbp)
movl $0x8, %edx
callq 0x34a0
leaq -0x240(%rbp), %rdi
callq 0x33e0
movq -0x260(%rbp), %rdi
callq 0x3410
movb %al, -0x251(%rbp)
jmp 0x7cf2
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x7d01
jmp 0x7de7
jmp 0x7d03
leaq -0x220(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x3080
movq %rax, -0x270(%rbp)
jmp 0x7d1f
movq -0x270(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33a0
movb %al, -0x271(%rbp)
jmp 0x7d3d
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x7d49
jmp 0x7dc6
leaq -0x240(%rbp), %rdi
callq 0x31e0
cmpq $0x5, %rax
jne 0x7d5d
jmp 0x7da8
leaq 0x5661(%rip), %rdi      # 0xd3c5
leaq 0x5676(%rip), %rsi      # 0xd3e1
movl $0x23, %edx
leaq 0x5676(%rip), %rcx      # 0xd3ed
callq 0x31b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3190
leaq -0x220(%rbp), %rdi
callq 0x30b0
jmp 0x7e1c
movq -0x268(%rbp), %rdi
addq $0x40, %rdi
leaq -0x240(%rbp), %rsi
callq 0x8270
jmp 0x7dc1
jmp 0x7d03
leaq -0x220(%rbp), %rdi
callq 0x3090
jmp 0x7dd4
movl $0x0, -0x4(%rbp)
movl $0x1, -0x250(%rbp)
jmp 0x7df8
movl $0x1, -0x4(%rbp)
movl $0x1, -0x250(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3190
leaq -0x220(%rbp), %rdi
callq 0x30b0
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x40, %rdi
callq 0x8360
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x40, %rdi
callq 0x8390
movq %rax, -0x20(%rbp)
callq 0x30c0
cltd
idivl -0x14(%rbp)
movl %edx, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7f9f
leaq -0x20(%rbp), %rdi
callq 0x83c0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7f83
leaq -0x20(%rbp), %rdi
callq 0x83e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3110
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
callq 0x7f10
movq %rax, -0x18(%rbp)
movq 0xbfca(%rip), %rdi      # 0x13fc8
leaq 0x5412(%rip), %rsi      # 0xd417
callq 0x32a0
movq %rax, %rdi
movq 0xbfa4(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x8390
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x8440
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8410
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x8056
jmp 0x8062
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x806b
jmp 0x80a6
leaq -0x20(%rbp), %rdi
callq 0x83e0
movq %rax, %rsi
movq 0xbf4a(%rip), %rdi      # 0x13fc8
callq 0x3270
movq %rax, %rdi
movq 0xbf2b(%rip), %rsi      # 0x13fb8
callq 0x32f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x83c0
jmp 0x802a
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jle 0x8138
movq 0xbf0a(%rip), %rdi      # 0x13fc8
leaq 0x50d7(%rip), %rsi      # 0xd19c
callq 0x32a0
movq %rax, %rdi
movq 0xbee4(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xbee8(%rip), %rdi      # 0x13fc8
leaq 0x535a(%rip), %rsi      # 0xd441
callq 0x32a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x5344(%rip), %rsi      # 0xd446
callq 0x32a0
movq %rax, %rdi
movq 0xbea7(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xbeab(%rip), %rdi      # 0x13fc8
leaq 0x5078(%rip), %rsi      # 0xd19c
callq 0x32a0
movq %rax, %rdi
movq 0xbe85(%rip), %rsi      # 0x13fb8
callq 0x32f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0xbe6d(%rip), %rdi      # 0x13fc8
leaq 0x52ef(%rip), %rsi      # 0xd451
callq 0x32a0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x3270
movq %rax, %rdi
leaq 0x52ea(%rip), %rsi      # 0xd46b
callq 0x32a0
movq %rax, %rdi
movq 0xbe28(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x8470
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x84e0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x84a0
testb $0x1, %al
jne 0x81ca
jmp 0x8224
leaq -0x10(%rbp), %rdi
callq 0x8510
movq %rax, %rsi
movq 0xbdeb(%rip), %rdi      # 0x13fc8
callq 0x3270
movq %rax, %rdi
leaq 0x5293(%rip), %rsi      # 0xd47f
callq 0x32a0
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x8510
movq -0x28(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0x3450
movq %rax, %rdi
movq 0xbda4(%rip), %rsi      # 0x13fb8
callq 0x32f0
leaq -0x10(%rbp), %rdi
callq 0x8530
jmp 0x81a6
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33e0
movq -0x60(%rbp), %rsi
movq 0xaaf6(%rip), %rdi      # 0x13fe0
callq 0x33b0
movq %rax, -0x68(%rbp)
jmp 0x94f5
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x33a0
movb %al, -0x69(%rbp)
jmp 0x950d
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x9519
jmp 0x95e1
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x80(%rbp)
callq 0x8390
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x8440
movq -0x60(%rbp), %rdx
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9720
movq %rax, -0x78(%rbp)
jmp 0x9552
movq -0x50(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x8440
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x96f0
testb $0x1, %al
jne 0x957e
jmp 0x95dd
movq 0xaa43(%rip), %rdi      # 0x13fc8
leaq 0x3f25(%rip), %rsi      # 0xd4b1
callq 0x32a0
movq %rax, -0x88(%rbp)
jmp 0x959a
movq -0x88(%rbp), %rdi
movq 0xaa10(%rip), %rsi      # 0x13fb8
callq 0x32f0
jmp 0x95af
movq 0xaa12(%rip), %rdi      # 0x13fc8
leaq 0x3f23(%rip), %rsi      # 0xd4e0
callq 0x32a0
jmp 0x95c4
jmp 0x95df
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3190
jmp 0x9647
jmp 0x9627
jmp 0x9619
movq 0xa9e0(%rip), %rdi      # 0x13fc8
leaq 0x3f0a(%rip), %rsi      # 0xd4f9
callq 0x32a0
movq %rax, -0x90(%rbp)
jmp 0x95fd
movq -0x90(%rbp), %rdi
movq 0xa9ad(%rip), %rsi      # 0x13fb8
callq 0x32f0
jmp 0x9612
xorl %edi, %edi
callq 0x3370
jmp 0x961b
movb $0x1, %al
testb $0x1, %al
jne 0x94df
jmp 0x9627
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x963a
movq -0x60(%rbp), %rdi
callq 0x3190
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
// File: m-wiesner[P]Jotto/ManualGuesser.cpp
// Function: ManualGuesser::guess[abi:cxx11]() const
string ManualGuesser::guess() const
{
    cout << "Enter guess: ";
    string g = random_guess(); 
    cout << "\r";
    return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xa94e(%rip), %rdi      # 0x13fc8
movq %rdi, -0x30(%rbp)
leaq 0x3e1e(%rip), %rsi      # 0xd4a3
callq 0x32a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, -0x11(%rbp)
callq 0x94b0
movq -0x30(%rbp), %rdi
leaq 0x3b2a(%rip), %rsi      # 0xd1d0
callq 0x32a0
jmp 0x96ad
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x96d9
jmp 0x96d0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3190
jmp 0x96e3
movq -0x40(%rbp), %rdi
callq 0x3190
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x40, %rdi
callq 0x9cf0
movq %rax, -0x10(%rbp)
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x8710
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0x9a85
jmp 0x9adf
leaq -0x10(%rbp), %rdi
callq 0x9d50
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x9bf0
testb $0x1, %al
jne 0x9aa0
jmp 0x9ad4
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9dd0
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x9d80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9add
leaq -0x10(%rbp), %rdi
callq 0x9df0
jmp 0x9a61
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x9cf0
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x40, %rdi
callq 0x8710
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
callq 0x9e60
movq %rax, %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9e10
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x40, %rdi
callq 0x8710
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9d20
testb $0x1, %al
jne 0x9b46
jmp 0x9b70
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9dd0
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x9d80
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x9ea0
testb $0x1, %al
jne 0x9b83
jmp 0x9be4
movq 0xa43e(%rip), %rdi      # 0x13fc8
leaq 0x398d(%rip), %rsi      # 0xd51e
callq 0x32a0
movq %rax, %rdi
movq 0xa418(%rip), %rsi      # 0x13fb8
callq 0x32f0
movq 0xa41c(%rip), %rdi      # 0x13fc8
leaq 0x399c(%rip), %rsi      # 0xd54f
callq 0x32a0
movq 0xa409(%rip), %rdi      # 0x13fc8
leaq 0x39bd(%rip), %rsi      # 0xd583
callq 0x32a0
movq %rax, %rdi
movq 0xa3e3(%rip), %rsi      # 0x13fb8
callq 0x32f0
movl $0x1, %edi
callq 0x3370
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7f30
movq -0x60(%rbp), %rdi
callq 0x7f10
movq %rax, -0x58(%rbp)
jmp 0xa27e
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movl %eax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
addq $0x40, %rdi
callq 0x8390
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x8440
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8410
testb $0x1, %al
jne 0xa2cc
jmp 0xa375
callq 0x30c0
cltd
idivl -0x18(%rbp)
cvtsi2sd %edx, %xmm1
cvtsi2sdl -0x18(%rbp), %xmm0
movsd 0x32c2(%rip), %xmm2     # 0xd5a8
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa365
leaq -0x40(%rbp), %rdi
callq 0x83e0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xa3a0
movsd %xmm0, -0x78(%rbp)
jmp 0xa30c
movsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0xa35c
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x83e0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3040
jmp 0xa343
jmp 0xa35c
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3190
jmp 0xa395
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa367
leaq -0x40(%rbp), %rdi
callq 0x83c0
jmp 0xa2a5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa388
movq -0x70(%rbp), %rdi
callq 0x3190
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3460
nop
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
addq $0x40, %rdi
callq 0x8390
movq %rax, -0x48(%rbp)
movq -0xc0(%rbp), %rdi
addq $0x40, %rdi
callq 0x8440
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8410
testb $0x1, %al
jne 0xa3f5
jmp 0xa4b3
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3110
leaq -0x48(%rbp), %rdi
callq 0x83e0
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x3110
jmp 0xa41c
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6440
movl %eax, -0xc4(%rbp)
jmp 0xa434
movl -0xc4(%rbp), %eax
cltq
movsd 0x3174(%rip), %xmm0     # 0xd5b8
addsd -0x40(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x40(%rbp,%rax,8)
leaq -0x90(%rbp), %rdi
callq 0x3190
leaq -0x70(%rbp), %rdi
callq 0x3190
leaq -0x48(%rbp), %rdi
callq 0x83c0
jmp 0xa3cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xa4a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3190
leaq -0x70(%rbp), %rdi
callq 0x3190
jmp 0xa5a1
xorps %xmm0, %xmm0
movsd %xmm0, -0xa8(%rbp)
movl $0x0, -0xac(%rbp)
cmpl $0x6, -0xac(%rbp)
jge 0xa590
movq -0xc0(%rbp), %rdi
movslq -0xac(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
movsd %xmm0, -0xd8(%rbp)
addq $0x40, %rdi
callq 0x8360
movsd -0xd8(%rbp), %xmm0
movq %rax, %xmm1
movaps 0x30b2(%rip), %xmm2     # 0xd5c0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x30b6(%rip), %xmm2     # 0xd5d0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd 0x3073(%rip), %xmm0     # 0xd5b0
mulsd -0xb8(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xa5b0
movaps %xmm0, %xmm2
movsd -0xd0(%rbp), %xmm0
movsd -0xa8(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0xa4c8
movsd -0xa8(%rbp), %xmm0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3460
nopl (%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
callq 0xac80
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x7ee0
jmp 0xa650
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x7ee0
jmp 0xa65f
movq -0xb0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0xa7b0
jmp 0xa678
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaca0
movq %rax, -0xc0(%rbp)
jmp 0xa691
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x3380
movq -0xc8(%rbp), %rdi
callq 0x3190
movq -0xb0(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0xa7b0
jmp 0xa6d0
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xaca0
movq %rax, -0xd0(%rbp)
jmp 0xa6e9
movq -0xd0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x3380
leaq -0xa8(%rbp), %rdi
callq 0x3190
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3190
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa791
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa788
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa77f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3190
jmp 0xa77f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3190
leaq -0x68(%rbp), %rdi
callq 0x3190
leaq -0x38(%rbp), %rdi
callq 0x3190
movq -0xb8(%rbp), %rdi
callq 0x50a0
movq -0x40(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: mgronhol[P]Ullur/ullur.cpp
// Function: multiget(std::unordered_map<unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, std::hash<unsigned long>, std::equal_to<unsigned long>, std::allocator<std::pair<unsigned long const, std::vector<unsigned long, std::allocator<unsigned long>>>>>&, unsigned long)
std::vector< uint64_t > multiget( std::unordered_map< uint64_t, std::vector< uint64_t > > &db, uint64_t key ){
	std::vector< uint64_t > out;
	std::unordered_map< uint64_t, std::vector< uint64_t > >::iterator it;
	
	it = db.find( key );
	if( it != db.end() ){
		for( size_t i = 0 ; i < (it->second).size() ; ++i ){
			out.push_back( (it->second)[i] );
			}
		}
	
	return out;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
callq 0x4a20
leaq 0x50(%rsp), %rdi
callq 0x4a30
jmp 0x26f6
movq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x4a40
movq %rax, 0x10(%rsp)
jmp 0x270c
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4a90
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4a70
testb $0x1, %al
jne 0x2747
jmp 0x27d5
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4ac0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x4ae0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x27d3
leaq 0x50(%rsp), %rdi
callq 0x4ac0
movq %rax, %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x4b70
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4b00
jmp 0x27a7
jmp 0x27a9
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2750
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x4b90
jmp 0x27f5
jmp 0x27d5
movb $0x1, 0x5f(%rsp)
testb $0x1, 0x5f(%rsp)
jne 0x27eb
movq 0x18(%rsp), %rdi
callq 0x4b90
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x2440
nop
// File: mgronhol[P]Ullur/ullur.cpp
// Function: send_string(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void send_string( int sock, std::string str ){
	const char *data = str.c_str();
	size_t L = 0;
	int n;
	while( L < str.size() ){
		n = send( sock, data + L, str.size() - L, 0 );
		
		if( n >= 0 ){ L += n; }
		else {
			std::cout << "Error: " << strerror( errno ) << ", L = "<< L << std::endl;
			return;
			}
		}
	}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x20(%rsp)
movl %edi, %eax
movq 0x20(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl %eax, 0x54(%rsp)
movq %rdi, 0x48(%rsp)
callq 0x2130
movq %rax, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x21f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x290c
movq 0x28(%rsp), %rdi
movl 0x54(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x21f0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
subq 0x38(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2170
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
jl 0x28ab
movslq 0x34(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x2907
movq 0x10726(%rip), %rdi     # 0x12fd8
leaq 0xa79b(%rip), %rsi      # 0xd054
callq 0x2290
movq %rax, (%rsp)
callq 0x2030
movl (%rax), %edi
callq 0x2100
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2290
movq %rax, %rdi
leaq 0xa778(%rip), %rsi      # 0xd05c
callq 0x2290
movq %rax, %rdi
movq 0x38(%rsp), %rsi
callq 0x2090
movq %rax, %rdi
movq 0x106c8(%rip), %rsi     # 0x12fc8
callq 0x22e0
jmp 0x290c
jmp 0x2831
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: mgronhol[P]Ullur/ullur.cpp
// Function: handle_put[abi:cxx11](double, double, unsigned long)
std::string handle_put( double x, double y, uint64_t id ){
	std::string out;
	uint64_t H;
	H = compute_hash( x, y );
	hashes.insert( H );
	//database.insert( std::pair< uint64_t, uint64_t >( H, id ) );
	if( database.find( H ) != database.end() ){
		database[H].push_back( id );
		}
	else{
		database[H] = std::vector< uint64_t >();
		database[H].push_back( id );
		}
	out = "Ok.\r\n";

	return out;
	}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xc0(%rsp)
movsd %xmm0, 0xb8(%rsp)
movsd %xmm1, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x23b0
movsd 0xb8(%rsp), %xmm0
movsd 0xb0(%rsp), %xmm1
callq 0xa5f0
movq %rax, 0x48(%rsp)
jmp 0x29b1
movq 0x48(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x108f3(%rip), %rdi     # 0x132b8
leaq 0x98(%rsp), %rsi
callq 0x4bf0
movb %dl, 0x2f(%rsp)
movq %rax, 0x30(%rsp)
jmp 0x29dd
movb 0x2f(%rsp), %al
movq 0x30(%rsp), %rcx
movq %rcx, 0x78(%rsp)
movb %al, 0x80(%rsp)
leaq 0x108ef(%rip), %rdi     # 0x132e8
leaq 0x98(%rsp), %rsi
callq 0x4a40
movq %rax, 0x20(%rsp)
jmp 0x2a0d
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x108ca(%rip), %rdi     # 0x132e8
callq 0x4a90
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4a70
testb $0x1, %al
jne 0x2a3d
jmp 0x2a8a
leaq 0x108a4(%rip), %rdi     # 0x132e8
leaq 0x98(%rsp), %rsi
callq 0x4c50
movq %rax, 0x18(%rsp)
jmp 0x2a58
movq 0x18(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x4b00
jmp 0x2a6c
jmp 0x2b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2b69
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4a20
leaq 0x1083c(%rip), %rdi     # 0x132e8
leaq 0x98(%rsp), %rsi
callq 0x4c50
movq %rax, 0x10(%rsp)
jmp 0x2ac0
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x4c80
movq (%rsp), %rdi
callq 0x4b90
leaq 0x10805(%rip), %rdi     # 0x132e8
leaq 0x98(%rsp), %rsi
callq 0x4c50
movq %rax, 0x8(%rsp)
jmp 0x2af7
movq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x4b00
jmp 0x2b0b
jmp 0x2b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4b90
jmp 0x2b69
movq 0x38(%rsp), %rdi
leaq 0xa52a(%rip), %rsi      # 0xd063
callq 0x2380
jmp 0x2b40
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x2b5c
movq 0x38(%rsp), %rdi
callq 0x21c0
movq 0x40(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x21c0
movq 0x90(%rsp), %rdi
callq 0x2440
// File: mgronhol[P]Ullur/ullur.cpp
// Function: handle_geo_put[abi:cxx11](double, double, unsigned long)
std::string handle_geo_put( double x, double y, uint64_t id ){
	// lat = -90 .. 90
	// lon = -180 .. 180

	x = (x + 90.0)/(2*90.0);
	y = (y + 180)/(2*180.0);

	return handle_put( x, y, id );
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movsd 0xa46f(%rip), %xmm0     # 0xd018
addsd 0x18(%rsp), %xmm0
movsd 0xa459(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xa447(%rip), %xmm0     # 0xd010
addsd 0x10(%rsp), %xmm0
movsd 0xa431(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq 0x8(%rsp), %rsi
callq 0x2950
movq (%rsp), %rax
addq $0x28, %rsp
retq
// File: mgronhol[P]Ullur/ullur.cpp
// Function: handle_geo_get[abi:cxx11](double, double, double)
std::string handle_geo_get( double x, double y, double r ){
	// lat = -90 .. 90
	// lon = -180 .. 180

	x = (x + 90.0)/(2*90.0);
	y = (y + 180)/(2*180.0);

	r = r / ( 6380e3 * 3.14159265358979323 * 2 ); // Divide by Earth's circumfence

	return handle_get( x, y, r );
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd 0x9e9e(%rip), %xmm0     # 0xd018
addsd 0x18(%rsp), %xmm0
movsd 0x9e88(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x9e76(%rip), %xmm0     # 0xd010
addsd 0x10(%rsp), %xmm0
movsd 0x9e60(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
movsd 0x9e68(%rip), %xmm1     # 0xd028
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x2c00
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: mgronhol[P]Ullur/ullur.cpp
// Function: handle_geo_getr[abi:cxx11](double, double, double, double)
std::string handle_geo_getr( double x0, double y0, double x1, double y1 ){
	// lat = -90 .. 90
	// lon = -180 .. 180

	x0 = (x0 + 90.0)/(2*90.0);
	y0 = (y0 + 180)/(2*180.0);

	x1 = (x1 + 90.0)/(2*90.0);
	y1 = (y1 + 180)/(2*180.0);

	return handle_getr( x0, y0, x1, y1 );
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movsd 0x97f7(%rip), %xmm0     # 0xd018
addsd 0x28(%rsp), %xmm0
movsd 0x97e1(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x97cf(%rip), %xmm0     # 0xd010
addsd 0x20(%rsp), %xmm0
movsd 0x97b9(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x97b7(%rip), %xmm0     # 0xd018
addsd 0x18(%rsp), %xmm0
movsd 0x97a1(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x978f(%rip), %xmm0     # 0xd010
addsd 0x10(%rsp), %xmm0
movsd 0x9779(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
callq 0x31f0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
// File: mgronhol[P]Ullur/ullur.cpp
// Function: handle_del[abi:cxx11](unsigned long)
std::string handle_del( uint64_t id ){
	std::unordered_map< uint64_t, std::vector< uint64_t > >::iterator it;
	/* Fix this, probably broken... */
	
	it = database.find( id );
	if( it != database.end() ){
		hashes.erase( it->first );
		database.erase( it );
		}
	

	return "Ok.\r\n";
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4a30
leaq 0xf9fc(%rip), %rdi      # 0x132e8
leaq 0x58(%rsp), %rsi
callq 0x4a40
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0xf9dc(%rip), %rdi      # 0x132e8
callq 0x4a90
movq %rax, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4a70
testb $0x1, %al
jne 0x392b
jmp 0x3964
leaq 0x50(%rsp), %rdi
callq 0x4ac0
movq %rax, %rsi
leaq 0xf979(%rip), %rdi      # 0x132b8
callq 0x4e80
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
leaq 0xf98e(%rip), %rdi      # 0x132e8
callq 0x4eb0
movq %rax, 0x30(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2450
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x96e1(%rip), %rsi      # 0xd063
callq 0x2390
jmp 0x3989
leaq 0x2f(%rsp), %rdi
callq 0x2300
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x2300
movq 0x20(%rsp), %rdi
callq 0x2440
nop
// File: mgronhol[P]Ullur/ullur.cpp
// Function: load_append_log()
void load_append_log(){

	std::string line;
	std::ifstream handle( "ullur.dump" );

	if( handle.is_open() ){
		std::cout << "Loading data from disk..." << std::endl;
		while( handle.good() ){
			std::getline( handle, line );
			if( line.size() < 5 ){ continue; }
			
			line = line.substr( 0, line.find_first_of( '\r' ) );
			
			line += "\r\n";
			
			handle_message( line, -1 );
			}
		}
	
	handle.close();
	
	
	}

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
leaq 0x298(%rsp), %rdi
callq 0x23b0
leaq 0x8f11(%rip), %rsi      # 0xd0fc
leaq 0x90(%rsp), %rdi
movl $0x8, %edx
callq 0x2460
jmp 0x41ff
leaq 0x90(%rsp), %rdi
callq 0x23f0
movb %al, 0x3f(%rsp)
jmp 0x4212
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x421f
jmp 0x4381
movq 0xedb2(%rip), %rdi      # 0x12fd8
leaq 0x8eda(%rip), %rsi      # 0xd107
callq 0x2290
movq %rax, 0x30(%rsp)
jmp 0x4239
movq 0x30(%rsp), %rdi
movq 0xed83(%rip), %rsi      # 0x12fc8
callq 0x22e0
jmp 0x424c
jmp 0x424e
movq 0x90(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x90(%rsp,%rax), %rdi
callq 0x2430
movb %al, 0x2f(%rsp)
jmp 0x426d
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x427a
jmp 0x437f
leaq 0x90(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x2070
jmp 0x4291
leaq 0x298(%rsp), %rdi
callq 0x21f0
cmpq $0x5, %rax
jae 0x42e5
jmp 0x424e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x43b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x20b0
jmp 0x43b2
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x20(%rsp)
leaq 0x298(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0xd, %esi
callq 0x21d0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rax, %rcx
leaq 0x60(%rsp), %rdi
callq 0x22c0
jmp 0x431e
leaq 0x298(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x60(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x2350
movq 0x8(%rsp), %rdi
callq 0x21c0
movq 0x10(%rsp), %rdi
leaq 0x8d16(%rip), %rsi      # 0xd066
callq 0x2270
jmp 0x4357
leaq 0x40(%rsp), %rdi
leaq 0x298(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x39c0
jmp 0x4370
leaq 0x40(%rsp), %rdi
callq 0x21c0
jmp 0x424e
jmp 0x4381
leaq 0x90(%rsp), %rdi
callq 0x2080
jmp 0x4390
leaq 0x90(%rsp), %rdi
callq 0x20b0
leaq 0x298(%rsp), %rdi
callq 0x21c0
addq $0x2b8, %rsp            # imm = 0x2B8
retq
leaq 0x298(%rsp), %rdi
callq 0x21c0
movq 0x88(%rsp), %rdi
callq 0x2440
nopl (%rax)